rtype-native 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a5d14f3ae8593646d772106c340e8d41b594c4f
+  data.tar.gz: ec5849c75b6a42d8c30dfe41bf2eb48a0fe54bb5
+SHA512:
+  metadata.gz: fddff4c61beacc969280f481972b339231b20dcc617f6c7f941d76b7b4c92d2baa70b2b20d5357ea0ff653abe2c6961e002dac0b2b8321be2a7efc3f31a70cc5
+  data.tar.gz: 23f5bc94ee53094bdeef9ea2f98073086bc9ac08a1f63d4d27b77e152acfdc267fc92b130d97a9da722fc560f1a854008e67ff61e9133311597af922123aa19e

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,448 @@
+# 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 native extension is used. Rtype itself without it is pure-ruby gem, therefore you can use Rtype in JRuby, etc.
+
+## 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 native extension.
+
+Just run `gem install rtype-native` or add `gem 'rtype-native'` to your `Gemfile`, then Rtype use it.
+(Do not `require 'rtype-native'`)
+
+It is only for MRI or RBX. JRuby extension not supported yet.
+
+## 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
+```
+Ruby version: 2.1.7
+Ruby engine: ruby
+Ruby description: ruby 2.1.7p400 (2015-08-18 revision 51632) [x64-mingw32]
+Rtype version: 0.2.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.600k i/100ms
+               rtype    25.735k i/100ms
+              rubype    20.922k i/100ms
+                 sig     8.960k i/100ms
+           contracts     4.659k i/100ms
+           typecheck     1.102k i/100ms
+Calculating -------------------------------------
+                pure      3.273M (± 2.4%) i/s -     16.435M
+               rtype    340.376k (± 1.9%) i/s -      1.724M
+              rubype    268.253k (± 4.2%) i/s -      1.339M
+                 sig    100.050k (± 1.9%) i/s -    501.760k
+           contracts     50.027k (± 2.0%) i/s -    251.586k
+           typecheck     11.317k (± 1.4%) i/s -     57.304k
+
+Comparison:
+                pure:  3272978.0 i/s
+               rtype:   340375.8 i/s - 9.62x slower
+              rubype:   268252.5 i/s - 12.20x slower
+                 sig:   100050.1 i/s - 32.71x slower
+           contracts:    50026.9 i/s - 65.42x slower
+           typecheck:    11317.1 i/s - 289.21x slower
+```
+
+### JRuby
+Without Rubype that doesn't support JRuby
+
+```
+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.2.0
+Sig version: 1.0.1
+Contracts version: 0.13.0
+Typecheck version: 0.1.2
+Warming up --------------------------------------
+                pure    29.127k i/100ms
+               rtype     4.566k i/100ms
+                 sig     4.162k i/100ms
+           contracts   776.000  i/100ms
+           typecheck   981.000  i/100ms
+Calculating -------------------------------------
+                pure      6.705M (±12.0%) i/s -     32.826M
+               rtype     89.262k (± 3.3%) i/s -    447.468k
+                 sig     74.070k (± 2.0%) i/s -    370.418k
+           contracts     25.399k (± 2.9%) i/s -    127.264k
+           typecheck     12.461k (± 9.0%) i/s -     61.803k
+
+Comparison:
+                pure:  6705166.5 i/s
+               rtype:    89262.5 i/s - 75.12x slower
+                 sig:    74070.1 i/s - 90.52x slower
+           contracts:    25398.9 i/s - 263.99x slower
+           typecheck:    12460.7 i/s - 538.10x 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/ext/rtype/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile("rtype/rtype_native")