rtype-java 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 507e4b1a4282df7820b412b246c6686a9b934fea
+  data.tar.gz: 1cc94f2f7401f544cc10c81b7cd9ef27fe8911e1
+SHA512:
+  metadata.gz: e8aa68a2002d14d410d161616a32dd8ced5c6bd4e8069b3053dbdde838fd0130a9e39d20f81d0e473cf7e269e5433bbfb8266abcd81c5ddee3d60ae2cf717020
+  data.tar.gz: fbf54ee612438f1eaff516deb3439732c3cd8ab88810184f0abb9dc1bd71c82d0f0e359192d706360b7ee98ffdf46938c669c1b1b6bc80723a37013314ef8c1c

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec :name => 'rtype'

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sputnik Gugja
+
+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,470 @@
+# Rtype: ruby with type
+[![Gem Version](https://badge.fury.io/rb/rtype.svg)](https://badge.fury.io/rb/rtype)
+[![Build Status](https://travis-ci.org/sputnikgugja/rtype.svg?branch=master)](https://travis-ci.org/sputnikgugja/rtype)
+[![Coverage Status](https://coveralls.io/repos/github/sputnikgugja/rtype/badge.svg?branch=master)](https://coveralls.io/github/sputnikgugja/rtype?branch=master)
+
+You can do the type checking in Ruby with this gem!
+
+```ruby
+require 'rtype'
+
+rtype :sum, [:to_i, Numeric] => Numeric
+def sum(a, b)
+  a.to_i + b
+end
+
+sum(123, "asd")
+# (Rtype::ArgumentTypeError) for 2nd argument:
+# Expected "asd" to be a Numeric
+
+class Test
+  rtype_self :invert, {state: Boolean} => Boolean
+  def self.invert(state:)
+    !state
+  end
+end
+
+Test::invert(state: 0)
+# (Rtype::ArgumentTypeError) for 'state' argument:
+# Expected 0 to be a Boolean
+```
+
+## Requirements
+- Ruby >= 2.1
+- MRI or RBX
+  - If C native extension is used, otherwise it is not required
+- JRuby
+  - If Java extension is used, otherwise it is not required
+
+## Features
+- Provide type checking for argument and return
+- Support type checking for [keyword argument](#keyword-argument)
+- [Type checking for array elements](#array)
+- [Duck typing](#duck-typing)
+- Custom type behavior
+
+## Installation
+Run `gem install rtype` or add `gem 'rtype'` to your `Gemfile`
+
+And add to your `.rb` source file:
+```ruby
+require 'rtype'
+```
+
+### Native extension
+Rtype itself is pure-ruby gem. but you can make it more faster by using native extension.
+
+#### Native extension for MRI, RBX
+Just run
+```ruby
+gem install rtype-native
+```
+or add to your `Gemfile`:
+```ruby
+gem 'rtype-native'
+```
+then, Rtype use it. (Do not `require 'rtype-native'`)
+
+#### Java extension for JRuby
+Just run
+```ruby
+gem install rtype-java
+```
+or add to your `Gemfile`:
+```ruby
+gem 'rtype-java'
+```
+then, Rtype use it. (Do not `require 'rtype-java'`)
+
+## Usage
+
+### Supported Type Behaviors
+- `Module`
+  - Value must be an instance of this module/class or one of its superclasses
+  - `Any` : An alias for `BasicObject` (means Any Object)
+  - `Boolean` : `true` or `false`
+- `Symbol`
+  - Value must have(respond to) a method with this name
+- `Regexp`
+  - Value must match this regexp pattern
+- `Range`
+  - Value must be included in this range
+- `Array` (tuple)
+  - Value must be an array
+  - Each of value's elements must be valid
+  - Value's length must be equal to the array's length
+  - Of course, nested array works
+  - Example: [Array](#array)
+  - This can be used as a tuple
+- `Proc`
+  - Value must return a truthy value for this proc
+- `true`
+  - Value must be **truthy**
+- `false`
+  - Value must be **falsy**
+- `nil`
+  - Only available for **return type**. void return type in other languages
+- Special Behaviors
+  - `Rtype::and(*types)` : Ensure value is valid for all the types
+    - It also can be used as `Rtype::Behavior::And[*types]` or `include Rtype::Behavior; And[...]`
+  - `Rtype::or(*types)` : Ensure value is valid for at least one of the types
+    - It also can be used as `Rtype::Behavior::Or[*types]` or `include Rtype::Behavior; Or[...]`
+  - `Rtype::xor(*types)` : Ensure value is valid for only one of the types
+    - It also can be used as `Rtype::Behavior::Xor[*types]` or `include Rtype::Behavior; Xor[...]`
+  - `Rtype::not(*types)` : Ensure value is not valid for all the types
+    - It also can be used as `Rtype::Behavior::Not[*types]` or `include Rtype::Behavior; Not[...]`
+  - `Rtype::nilable(type)` : Ensure value can be nil
+    - It also can be used as `Rtype::Behavior::Nilable[type]` or `include Rtype::Behavior; Nilable[...]`
+  - You can create custom behavior by extending `Rtype::Behavior::Base`
+
+### Examples
+
+#### Basic
+```ruby
+require 'rtype'
+
+class Example
+  rtype :test, [Integer] => nil
+  def test(i)
+  end
+  
+  rtype :any_type_arg, [Any] => nil
+  def any_type_arg(arg)
+  end
+  
+  rtype :return_type_test, [] => Integer
+  def return_type_test
+    "not integer"
+  end
+end
+
+e = Example.new
+e.test("not integer")
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected "not integer" to be a Integer
+
+e.any_type_arg("Any argument!") # Works
+
+e.return_type_test
+# (Rtype::ReturnTypeError) for return:
+# Expected "not integer" to be a Integer
+```
+
+#### Keyword argument
+```ruby
+require 'rtype'
+
+class Example
+  rtype :say_your_name, {name: String} => Any
+  def say_your_name(name:)
+    puts "My name is #{name}"
+  end
+  
+  # Mixing positional arguments and keyword arguments
+  rtype :name_and_age, [String, {age: Integer}] => Any
+  def name_and_age(name, age:)
+    puts "Name: #{name}, Age: #{age}"
+  end
+end
+
+Example.new.say_your_name(name: "Babo") # My name is Babo
+Example.new.name_and_age("Bamboo", age: 100) # Name: Bamboo, Age: 100
+
+Example.new.say_your_name(name: 12345)
+# (Rtype::ArgumentTypeError) for 'name' argument:
+# Expected 12345 to be a String
+```
+
+#### Duck typing
+```ruby
+require 'rtype'
+
+class Duck
+  rtype :says, [:to_i] => Any
+  def says(i)
+    puts "duck:" + " quack"*i.to_i
+  end
+end
+
+Duck.new.says("2") # duck: quack quack
+```
+
+#### Array
+This can be used as a tuple.
+
+```ruby
+rtype :func, [[Numeric, Numeric]] => Any
+def func(arr)
+  puts "Your location is (#{arr[0]}, #{arr[1]}). I will look for you. I will find you"
+end
+
+func [1, "str"]
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected [1, "str"] to be an array with 2 elements:
+# - [0] index : Expected 1 to be a Numeric
+# - [1] index : Expected "str" to be a Numeric
+
+func [1, 2, 3]
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected [1, 2, 3] to be an array with 2 elements:
+# - [0] index : Expected 1 to be a Numeric
+# - [1] index : Expected 2 to be a Numeric
+
+func [1]
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected [1] to be an array with 2 elements:
+# - [0] index : Expected 1 to be a Numeric
+# - [1] index : Expected nil to be a Numeric
+
+func [1, 2] # Your location is (1, 2). I will look for you. I will find you
+```
+
+#### rtype with attr_accessor
+`rtype_accessor`
+
+You can use `rtype_accessor_self` for static accessor.
+
+```ruby
+require 'rtype'
+
+class Example
+  rtype_accessor :value, String
+  attr_accessor :value
+  def initialize
+    @value = 456
+  end
+end
+
+Example.new.value = 123
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected 123 to be a String
+
+Example.new.value
+# (Rtype::ReturnTypeError) for return:
+# Expected 456 to be a String
+```
+
+#### Combined type
+```ruby
+### TEST 1 ###
+require 'rtype'
+
+class Example
+  rtype :and_test, [Rtype::and(String, :func)] => Any
+  def and_test(arg)
+  end
+end
+
+Example.new.and_test("A string")
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected "A string" to be a String
+# AND Expected "A string" to respond to :func
+```
+```ruby
+### TEST 2 ###
+# ... require rtype and define Example the same as above ...
+
+class String
+  def func; end
+end
+
+Example.new.and_test("A string") # Works!
+```
+
+#### Combined duck type
+Application of duck typing and combined type
+
+```ruby
+require 'rtype'
+
+module Game
+  ENEMY = [
+    :name,
+    :level
+  ]
+  
+  class Player < Entity
+    include Rtype::Behavior
+
+    rtype :attack, [And[*ENEMY]] => Any
+    def attacks(enemy)
+      "Player attacks '#{enemy.name}' (level #{enemy.level})!"
+    end
+  end
+  
+  class Slime < Entity
+    def name
+      "Powerful Slime"
+    end
+    
+    def level
+      123
+    end
+  end
+end
+
+Game::Player.new.attacks Game::Slime.new
+# Player attacks 'Powerful Slime' (level 123)!
+```
+
+#### Position of `rtype` && (symbol || string)
+```ruby
+require 'rtype'
+
+class Example
+  # Works. Recommended
+  rtype :hello_world, [Integer, String] => String
+  def hello_world(i, str)
+    puts "Hello? #{i} #{st
+  end
+  
+  # Works
+  def hello_world_two(i, str)
+    puts "Hello? #{i} #{str}"
+  end
+  rtype :hello_world_two, [Integer, String] => String
+  
+  # Also works (String will be converted to Symbol)
+  rtype 'hello_world_three', [Integer, String] => String
+  def hello_world_three(i, str)
+    puts "Hello? #{i} #{str}"
+  end
+end
+```
+
+#### Outside of module (root)
+Yes, it works
+
+```ruby
+rtype :say, [String] => Any
+def say(message)
+  puts message
+end
+
+say "Hello" # Hello
+```
+
+#### Static method
+Use `rtype_self`
+
+```ruby
+require 'rtype'
+
+class Example
+  rtype_self :say_ya, [:to_i] => Any
+  def self.say_ya(i)
+    puts "say" + " ya"*i.to_i
+  end
+end
+
+Example::say_ya(3) #say ya ya ya
+```
+
+#### Check type information
+This is just the 'information'
+
+Any change of this doesn't affect type checking
+
+```ruby
+require 'rtype'
+
+class Example
+  rtype :test, [:to_i] => Any
+  def test(i)
+  end
+end
+
+Example.new.method(:test).type_info
+# => [:to_i] => Any
+Example.new.method(:test).argument_type
+# => [:to_i]
+Example.new.method(:test).return_type
+# => Any
+```
+
+## Documentation
+[RubyDoc.info](http://www.rubydoc.info/gems/rtype)
+
+## Benchmarks
+Result of `rake benchmark` ([source](https://github.com/sputnikgugja/rtype/tree/master/benchmark/benchmark.rb))
+
+### MRI
+```
+Rtype with C native extension
+Ruby version: 2.1.7
+Ruby engine: ruby
+Ruby description: ruby 2.1.7p400 (2015-08-18 revision 51632) [x64-mingw32]
+Rtype version: 0.3.0
+Rubype version: 0.3.1
+Sig version: 1.0.1
+Contracts version: 0.13.0
+Typecheck version: 0.1.2
+Warming up --------------------------------------
+                pure    85.328k i/100ms
+               rtype    25.665k i/100ms
+              rubype    21.414k i/100ms
+                 sig     8.921k i/100ms
+           contracts     4.638k i/100ms
+           typecheck     1.110k i/100ms
+Calculating -------------------------------------
+                pure      3.282M (± 2.7%) i/s -     16.468M
+               rtype    339.065k (± 2.6%) i/s -      1.720M
+              rubype    266.893k (± 5.9%) i/s -      1.349M
+                 sig     99.952k (± 2.1%) i/s -    499.576k
+           contracts     49.693k (± 1.5%) i/s -    250.452k
+           typecheck     11.356k (± 1.6%) i/s -     57.720k
+
+Comparison:
+                pure:  3282431.9 i/s
+               rtype:   339064.9 i/s - 9.68x slower
+              rubype:   266892.9 i/s - 12.30x slower
+                 sig:    99952.2 i/s - 32.84x slower
+           contracts:    49693.0 i/s - 66.05x slower
+           typecheck:    11355.9 i/s - 289.05x slower
+```
+
+### JRuby
+Without Rubype that doesn't support JRuby
+
+```
+Rtype with Java extension
+Ruby version: 2.2.3
+Ruby engine: jruby
+Ruby description: jruby 9.0.5.0 (2.2.3) 2016-01-26 7bee00d Java HotSpot(TM) 64-Bit Server VM 25.60-b23 on 1.8.0_60-b27 +jit [Windows 10-amd64]
+Rtype version: 0.3.0
+Sig version: 1.0.1
+Contracts version: 0.13.0
+Typecheck version: 0.1.2
+Warming up --------------------------------------
+                pure     9.994k i/100ms
+               rtype     6.181k i/100ms
+                 sig     4.041k i/100ms
+           contracts   951.000  i/100ms
+           typecheck   970.000  i/100ms
+Calculating -------------------------------------
+                pure      7.128M (?±35.6%) i/s -     30.831M
+               rtype    121.556k (?± 6.2%) i/s -    605.738k
+                 sig     72.187k (?± 6.4%) i/s -    359.649k
+           contracts     24.984k (?± 3.9%) i/s -    125.532k
+           typecheck     12.041k (?± 9.5%) i/s -     60.140k
+
+Comparison:
+                pure:  7128373.0 i/s
+               rtype:   121555.8 i/s - 58.64x slower
+                 sig:    72186.8 i/s - 98.75x slower
+           contracts:    24984.5 i/s - 285.31x slower
+           typecheck:    12041.0 i/s - 592.01x slower
+```
+
+## Rubype, Sig
+Rtype is influenced by [Rubype](https://github.com/gogotanaka/Rubype) and [Sig](https://github.com/janlelis/sig).
+
+If you don't like Rtype, You can use other type checking gem such as Contracts, Rubype, Rtc, Typecheck, Sig.
+
+## Author
+Sputnik Gugja (sputnikgugja@gmail.com)
+
+## License
+MIT license (@ Sputnik Gugja)
+
+See `LICENSE` file.

data/Rakefile

@@ -0,0 +1,12 @@
+require "rspec/core/rake_task"
+
+# Default pattern is 'spec/**{,/*/**}/*_spec.rb'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+# Benchmark
+desc "Compare with pure ruby and other gems"
+task :benchmark do
+  ruby "benchmark/benchmark.rb"
+end

data/benchmark/benchmark.rb

@@ -0,0 +1,192 @@
+require 'benchmark/ips'
+
+is_mri = RUBY_ENGINE == 'ruby'
+
+require "rtype"
+require "rubype" if is_mri
+require "sig"
+require "contracts"
+require "contracts/version"
+require "typecheck"
+
+puts "Ruby version: #{RUBY_VERSION}"
+puts "Ruby engine: #{RUBY_ENGINE}"
+puts "Ruby description: #{RUBY_DESCRIPTION}"
+
+puts "Rtype version: #{Rtype::VERSION}"
+puts "Rubype version: #{Rubype::VERSION}" if is_mri
+puts "Sig version: #{Sig::VERSION}"
+puts "Contracts version: #{Contracts::VERSION}"
+puts "Typecheck version: #{Typecheck::VERSION}"
+
+class PureTest
+	def sum(x, y)
+		x + y
+	end
+
+	def mul(x, y)
+		x * y
+	end
+
+	def args(a, b, c, d)
+	end
+end
+pure_obj = PureTest.new
+
+class RtypeTest
+	rtype :sum, [Numeric, Numeric] => Numeric
+	def sum(x, y)
+		x + y
+	end
+
+	rtype :mul, [:to_i, :to_i] => Numeric
+	def mul(x, y)
+		x * y
+	end
+
+	rtype :args, [Integer, Numeric, String, :to_i] => Any
+	def args(a, b, c, d)
+	end
+end
+rtype_obj = RtypeTest.new
+
+if is_mri
+	class RubypeTest
+		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
+
+		def args(a, b, c, d)
+		end
+		typesig :args, [Integer, Numeric, String, :to_i] => Any
+	end
+	rubype_obj = RubypeTest.new
+end
+
+class SigTest
+	sig [Numeric, Numeric], Numeric,
+	def sum(x, y)
+		x + y
+	end
+
+	sig [:to_i, :to_i], Numeric,
+	def mul(x, y)
+		x * y
+	end
+
+	# nil means wildcard
+	sig [Integer, Numeric, String, :to_i], nil,
+	def args(a, b, c, d)
+	end
+end
+sig_obj = SigTest.new
+
+class ContractsTest
+	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
+
+	Contract Int, Num, String, RespondTo[:to_i] => Any
+	def args(a, b, c, d)
+	end
+end
+contracts_obj = ContractsTest.new
+
+class TypecheckTest
+	extend Typecheck
+
+	typecheck 'Numeric, Numeric -> Numeric',
+	def sum(x, y)
+		x + y
+	end
+
+	typecheck '#to_i, #to_i -> Numeric',
+	def mul(x, y)
+		x * y
+	end
+
+	typecheck 'Integer, Numeric, String, #to_i -> BasicObject',
+	def args(a, b, c, d)
+	end
+end
+typecheck_obj = TypecheckTest.new
+
+Benchmark.ips do |x|
+	x.report("pure") do |times|
+		i = 0
+		while i < times
+			pure_obj.sum(1, 2)
+			pure_obj.mul(1, 2)
+			pure_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("rtype") do |times|
+		i = 0
+		while i < times
+			rtype_obj.sum(1, 2)
+			rtype_obj.mul(1, 2)
+			rtype_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	if is_mri
+		x.report("rubype") do |times|
+			i = 0
+			while i < times
+				rubype_obj.sum(1, 2)
+				rubype_obj.mul(1, 2)
+				rubype_obj.args(1, 2, "c", 4)
+				i += 1
+			end
+		end
+	end
+	
+	x.report("sig") do |times|
+		i = 0
+		while i < times
+			sig_obj.sum(1, 2)
+			sig_obj.mul(1, 2)
+			sig_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("contracts") do |times|
+		i = 0
+		while i < times
+			contracts_obj.sum(1, 2)
+			contracts_obj.mul(1, 2)
+			contracts_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("typecheck") do |times|
+		i = 0
+		while i < times
+			typecheck_obj.sum(1, 2)
+			typecheck_obj.mul(1, 2)
+			typecheck_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.compare!
+end

data/spec/rtype_spec.rb

@@ -0,0 +1,547 @@
+require_relative 'spec_helper'
+
+describe Rtype do
+	let(:klass) do
+		Class.new do
+			attr_accessor :value
+
+			def initialize
+				@value = 123
+			end
+
+			def return_arg(obj)
+				obj
+			end
+
+			def three_args(a, b, c)
+			end
+
+			def three_kwargs(a:, b:, c:)
+			end
+
+			def return_nil(obj)
+				nil
+			end
+
+			def sum(a, b)
+				a + b
+			end
+
+			def kwarg(a:)
+				a
+			end
+
+			def sum_kwargs(a:, b:)
+				a + b
+			end
+
+			def arg_and_kwarg(a, b:)
+			end
+
+			def arg_and_kwargs(a, b:, c:)
+			end
+
+			def args_and_kwargs(a, b, c:, d:)
+			end
+
+			protected
+			def protected_func
+			end
+
+			private
+			def private_func
+			end
+		end
+	end
+
+	let(:instance) do
+		klass.new
+	end
+
+	describe 'Kernel#rtype' do
+		it "outside of module" do
+			rtype :test_args, [String] => Any
+			def test_args(str)
+			end
+
+			expect {test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+			rtype :test_return, [] => String
+			def test_return
+				369
+			end
+
+			expect {test_return}.to raise_error Rtype::ReturnTypeError
+		end
+
+		it "in module" do
+			class TestClass
+				rtype :test_args, [String] => Any
+				def test_args(str)
+				end
+			end
+
+			expect {TestClass.new.test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+			class TestClass
+				rtype :test_return, [] => String
+				def test_return
+					369
+				end
+			end
+
+			expect {TestClass.new.test_return}.to raise_error Rtype::ReturnTypeError
+		end
+	end
+
+	it "Kernel#rtype_self" do
+		class TestClass
+			rtype_self :static_test_args, [String] => Any
+			def self.static_test_args(str)
+			end
+		end
+
+		expect {TestClass::static_test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+		class TestClass
+			rtype_self :static_test_return, [] => String
+			def self.static_test_return
+				369
+			end
+		end
+
+		expect {TestClass::static_test_return}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_accessor' do
+		class TestClass
+			rtype_accessor :value, String
+			attr_accessor :value
+
+			def initialize
+				@value = 123
+			end
+		end
+		expect {TestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass.new.value}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_accessor_self' do
+		class TestClass
+			@@val = 123
+
+			rtype_accessor_self :value, String
+			def self.value=(val)
+				@@val = val
+			end
+			def self.value
+				@@val
+			end
+		end
+		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
+	end
+
+	describe 'Test type behaviors' do
+		describe 'Module' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [String] => Any
+				instance.return_arg("This is a string!")
+			end
+			it "is wrong" do
+				klass.send :rtype, :return_arg, [String] => Any
+				expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => String
+				expect {instance.return_nil("This is a string!")}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Symbol' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [:to_i] => Any
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [:to_i] => Any
+				expect {instance.return_arg(true)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => :odd?
+				expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Regexp' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [/cuba/] => Any
+				instance.return_arg("cuba")
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [/cuba/] => Any
+				expect {instance.return_arg("brazil")}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => /cuba/
+				expect {instance.return_nil("cuba")}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Range' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [1..10] => Any
+				instance.return_arg(5)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [1..10] => Any
+				expect {instance.return_arg(1001)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => 1..10
+				expect {instance.return_nil(5)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Array' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
+				instance.return_arg([123, 456])
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
+				expect {instance.return_arg([123, true])}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_arg, [Any] => [:to_i, :to_i]
+				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Proc' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [->(arg){!arg.nil?}] => Any
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [->(arg){!arg.nil?}] => Any
+				expect {instance.return_arg(nil)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => ->(arg){!arg.nil?}
+				expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'true' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [true] => Any
+				instance.return_arg(true)
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [true] => Any
+				expect {instance.return_arg(false)}.to raise_error Rtype::ArgumentTypeError
+				expect {instance.return_arg(nil)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_arg, [Any] => true
+				expect {instance.return_arg(false)}.to raise_error Rtype::ReturnTypeError
+				expect {instance.return_arg(nil)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'false' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [false] => Any
+				instance.return_arg(false)
+				instance.return_arg(nil)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [false] => Any
+				expect {instance.return_arg(true)}.to raise_error Rtype::ArgumentTypeError
+				expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_arg, [Any] => false
+				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
+				expect {instance.return_arg(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'nil' do
+			it "is only for return" do
+				klass.send :rtype, :return_nil, [] => nil
+				instance.return_nil(123)
+
+				klass.send :rtype, :return_arg, [] => nil
+				expect {instance.return_arg(123)}.to raise_error Rtype::ReturnTypeError
+			end
+			it "could not be used for args" do
+				expect {
+					klass.send :rtype, :return_arg, [nil] => Any
+				}.to raise_error Rtype::TypeSignatureError
+			end
+		end
+
+		describe 'Special type behaviors' do
+			it 'Rtype::Behavior::And' do
+				klass.send :rtype, :return_nil, [Rtype.and(:to_i, :chars)] => nil
+				instance.return_nil("Hello")
+				expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Or' do
+				klass.send :rtype, :return_nil, [Rtype.or(Integer, String)] => nil
+				instance.return_nil(123)
+				instance.return_nil("abc")
+				expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Nilable' do
+				klass.send :rtype, :return_nil, [Rtype.nilable(Integer)] => nil
+				instance.return_nil(nil)
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Not' do
+				klass.send :rtype, :return_nil, [Rtype.not(String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Xor' do
+				klass.send :rtype, :return_nil, [Rtype.xor(:to_i, String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
+	end
+
+	describe 'Signature' do
+		describe 'check arguments' do
+			it 'nothing' do
+				klass.send :rtype, :sum, [] => Any
+				instance.sum(1, 2)
+				instance.sum(1, 2.0)
+				instance.sum(1.0, 2.0)
+				instance.sum("a", "b")
+			end
+
+			it 'two' do
+				klass.send :rtype, :sum, [Integer, Integer] => Any
+				expect {instance.sum(1, 2.0)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one keyword argument' do
+				klass.send :rtype, :kwarg, {a: Float} => Any
+				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'two keyword argument' do
+				klass.send :rtype, :sum_kwargs, {a: Integer, b: Float} => Any
+				expect {instance.sum_kwargs(a: 1, b: 2)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one with one keyword argument' do
+				klass.send :rtype, :arg_and_kwarg, [Integer, {b: Float}] => Any
+				expect {instance.arg_and_kwarg(1, b: 2)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one with two keyword argument' do
+				klass.send :rtype, :arg_and_kwargs, [Integer, {c: String, d: String}] => Any
+				expect {instance.arg_and_kwargs(1, b: 2, c: 3)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'two with two keyword argument' do
+				klass.send :rtype, :args_and_kwargs, [Integer, Integer, {c: String, d: String}] => Any
+				expect {instance.args_and_kwargs(1, 2, c: 3, d: 4)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'string key could not be used for keyword argument' do
+				expect {
+					klass.send :rtype, :kwarg, {'a' => Float} => Any
+				}.to raise_error Rtype::TypeSignatureError
+			end
+
+			it 'only symbol key is used for keyword argument' do
+				klass.send :rtype, :kwarg, {:a => Float} => Any
+				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
+				expect {instance.kwarg(:a => 1)}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
+
+		describe 'check return' do
+			it 'Any' do
+				klass.send :rtype, :return_arg, [] => Any
+				instance.return_arg("str")
+			end
+
+			it 'Array (tuple)' do
+				klass.send :rtype, :return_arg, [] => [Integer, Float]
+				expect {instance.return_arg([1, 2])}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		it 'check arguments and return value' do
+			klass.send :rtype, :return_nil, [Float] => nil
+			expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			klass.send :rtype, :return_nil, [Integer] => Integer
+			expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+		end
+
+		describe 'wrong case' do
+			describe 'invalid signature form' do
+				it 'invalid argument signature' do
+					expect {
+						klass.send :rtype, :return_arg, Any => nil
+					}.to raise_error Rtype::TypeSignatureError
+				end
+				it 'invalid return signature' do
+					expect {
+						klass.send :rtype, :return_arg, [] => {}
+					}.to raise_error Rtype::TypeSignatureError
+				end
+
+				it 'invalid type behavior in arguments' do
+					expect {
+						klass.send :rtype, :sum_kwargs, [{a: Integer}, {b: Integer}] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, [123] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, ["abc"] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {a: 123} => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {a: {b: Integer}} => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {Object.new => Integer} => Any
+					}.to raise_error Rtype::TypeSignatureError
+				end
+
+				it 'invalid type behavior in return' do
+					expect {
+						klass.send :rtype, :return_arg, [] => 123
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, [] => "abc"
+					}.to raise_error Rtype::TypeSignatureError
+				end
+			end
+		end
+	end
+
+	describe "Implementation" do
+		it 'can be called before method definition' do
+			class TestClass
+				rtype :method_def, [Integer] => Any
+				def method_def(i)
+				end
+			end
+			expect {
+				TestClass.new.method_def("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'can be called after method definition' do
+			class TestClass
+				def method_def_2(i)
+				end
+				rtype :method_def_2, [Integer] => Any
+			end
+			expect {
+				TestClass.new.method_def_2("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'method name can be both symbol and string' do
+			class TestClass
+				rtype 'method_def_3', [Integer] => Any
+				def method_def_3(i)
+				end
+				rtype :method_def_4, [Integer] => Any
+				def method_def_4(i)
+				end
+			end
+			expect {
+				TestClass.new.method_def_3("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+			expect {
+				TestClass.new.method_def_4("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		describe 'method visibility works' do
+			it 'protected' do
+				expect {instance.protected_func}.to raise_error NoMethodError
+			end
+			it 'private' do
+				expect {instance.private_func}.to raise_error NoMethodError
+			end
+		end
+
+		context 'with empty argument signature' do
+			it 'accept any arguments' do
+				klass.send :rtype, :three_args, [] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when args length is more than arg signature length' do
+			it 'type checking ignore rest args' do
+				klass.send :rtype, :three_args, [String] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when keyword args contain a key not configured to rtype' do
+			it 'type checking ignore the key' do
+				klass.send :rtype, :three_kwargs, {a: String} => Any
+				instance.three_kwargs(a: "abc", b: 123, c: 456)
+			end
+		end
+	end
+
+	describe "Call Rtype`s static method directly" do
+		it 'Rtype::define_typed_method' do
+			Rtype::define_typed_method klass, :return_arg, [String] => Any
+			expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'Rtype::define_typed_accessor' do
+			Rtype::define_typed_accessor klass, :value, String
+			expect { instance.value = 123 }.to raise_error Rtype::ArgumentTypeError
+			expect { instance.value }.to raise_error Rtype::ReturnTypeError
+		end
+		
+		it 'Rtype::valid?' do
+			expect {
+				Rtype::valid?("Invalid type behavior", "Test Value")
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_arguments_type' do
+			expect {
+				Rtype::assert_arguments_type([Integer, String], [123, 123])
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_arguments_type_with_keywords' do
+			expect {
+				Rtype::assert_arguments_type_with_keywords([Integer, String], [123, "abc"], {arg: String}, {arg: 123})
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_return_type' do
+			expect {
+				Rtype::assert_return_type nil, "No nil"
+			}.to raise_error Rtype::ReturnTypeError
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'rtype'
+require 'rspec'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: rtype-java
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Sputnik Gugja
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rtype
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Java extension for Rtype
+email:
+- sputnikgugja@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- benchmark/benchmark.rb
+- ext/rtype/rtype_java.jar
+- spec/rtype_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sputnikgugja/rtype
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Java extension for Rtype
+test_files:
+- spec/rtype_spec.rb
+- spec/spec_helper.rb