rubype 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a1d6b7168106e0de86c7111cfe41bfe191a4217
-  data.tar.gz: 2663b2cfef26e3eb90ee0c0932be7d34bb562ddb
+  metadata.gz: 1c0f2d837a9a63da1544d73541bc6b6ef5e60958
+  data.tar.gz: c875157ae021117e74ec28014d313e4a5fd72f1b
 SHA512:
-  metadata.gz: 0dce04b7c97e12030468f044af562c51c04446ed033d17acd27da10355dae3751a0fd8bc74dc8c15e8cdde31d0c6d9710d420a2cf106c6a36495636ac4a9a20e
-  data.tar.gz: 85d34a6e01587cab72001f08f13ca372c39a72efdb52b6b3506b10b12b7de0582f4087a60b8d23929ecb6454921a74e26edf1b0760607493083f40906b355e0f
+  metadata.gz: ae15d7157d172321c3b31982bbbb83611f4e163a8278b27c7b96971b7be6d0ee1244d6d4fc8591ccd28549f1e5842929ea8cb274a69f01d0a425c586eeebd292
+  data.tar.gz: b7fe02373c1ce6a849ca232ad5f0139da7cf2f5655ce3d81e065e5abc0f04c7e6a0c0e9b789102076c6d6df1e028d2773ce79fd707e0e9c504e8644cbdcf1832

data/README.md

@@ -1,51 +1,23 @@
 # Ruby + Type = Rubype
 
 ```rb
+# Assert class of both args is Numeric and class of return is String
 def sum(x, y)
-  x + y
+  (x + y).to_s
 end
-typesig sum: [Numeric, Numeric => Numeric]
-```
-
-This gem brings you advantage of type without changing existing code's behavior.
+typesig sum: [Numeric, Numeric => String]
 
-Matz has mentioned Ruby3.0 with static type at some confluences. But almost all rubyists(include me) are not sure how typed Ruby is.
-
-But it's worth thinking more. This gem is kind of trial without so much side-effect.
-
-# Feature
-### Typed method can coexist with non-typed method
-
-```ruby
-# It's totally OK!!
-class MyClass
-  def method_with_type(x, y)
-    x + y
-  end
-  typesig sum: [Numeric, Numeric => Numeric]
-
-  def method_without_type(x, y)
-    'string'
-  end
+# Assert first arg has method #to_i
+def sum(x, y)
+  x.to_i + y
 end
+typesig sum: [:to_i, Numeric => Numeric]
 ```
 
-### Duck typing
 
-```ruby
-
-class MyClass
-  def foo(any_obj)
-    1
-  end
-  typesig sum: [Any => Numeric]
-end
+This gem brings you advantage of type without changing existing code's behavior.
 
-# It's totally OK!!
-MyClass.new.foo(1)
-# It's totally OK!!
-MyClass.new.foo('str')
-```
+# Feature
 
 ### Advantage of type
 * Meaningful error
@@ -54,7 +26,7 @@ MyClass.new.foo('str')
 ```rb
 require 'rubype'
 
-# ex1
+# ex1: Assert class of args and return
 class MyClass
   def sum(x, y)
     x + y
@@ -71,27 +43,85 @@ MyClass.new.sum(1, 2)
 #=> 3
 
 MyClass.new.sum(1, 'string')
-#=> ArgumentError: Wrong type of argument, type of "str" should be Numeric
+#=> Rubype::ArgumentTypeError: Expected MyClass#sum's 2th argument to be Numeric but got "string" instead
 
 MyClass.new.wrong_sum(1, 2)
-#=> TypeError: Expected wrong_sum to return Numeric but got "str" instead
+#=> Rubype::ReturnTypeError: Expected MyClass#wrong_sum to return Numeric but got "string" instead
+
+
+# ex2: Assert object has specified method
+class MyClass
+  def sum(x, y)
+    x.to_i + y
+  end
+  typesig sum: [:to_i, Numeric => Numeric]
+end
 
+MyClass.new.sum('1', 2)
+#=> 3
 
-# ex2
+MyClass.new.sum(:has_no_to_i, 2)
+#=> Rubype::ArgumentTypeError: Expected MyClass#sum's 1th argument to have method #to_i but got :has_no_to_i instead
+
+
+# ex3: You can use Any class, if you want
 class People
-  type People >= Any, def marry(people)
+  def marry(people)
     # Your Ruby code as usual
   end
+  typesig marry: [People => Any]
 end
-typesig marry: [People => Any]
 
 People.new.marry(People.new)
 #=> no error
 
 People.new.marry('non people')
-#=> ArgumentError: Wrong type of argument, type of "non people" should be People
+#=> Rubype::ArgumentTypeError: Expected People#marry's 1th argument to be People but got "non people" instead
+
+```
+
+### Typed method can coexist with non-typed method
+
+```ruby
+# It's totally OK!!
+class MyClass
+  def method_with_type(x, y)
+    x + y
+  end
+  typesig sum: [Numeric, Numeric => Numeric]
+
+  def method_without_type(x, y)
+    'string'
+  end
+end
 ```
 
+### Duck typing
+You can use `Any` class.
+```ruby
+class MyClass
+  def foo(any_obj)
+    1
+  end
+  typesig foo: [Any => Numeric]
+
+  def sum(x, y)
+    x.to_i + y
+  end
+  typesig sum: [:to_i, Numeric => Numeric]
+end
+
+# It's totally OK!!
+MyClass.new.foo(1)
+# It's totally OK!!
+MyClass.new.foo(:sym)
+
+
+# It's totally OK!!
+MyClass.new.sum(1, 2)
+# It's totally OK!!
+MyClass.new.sum('1', 2)
+```
 
 
 ## Installation
@@ -116,8 +146,7 @@ Commit your changes (`git commit -am 'Add some feature'`)
 
 Push to the branch (`git push origin my-new-feature`)
 
-Create a new Pull Request
+Create a new Pull Request to `develop` branch
 
 ## Credits
 [@chancancode](https://github.com/chancancode) and [This article](http://blog.codeclimate.com/blog/2014/05/06/gradual-type-checking-for-ruby/) first brought this to my attention. I've stolen some idea from them.
-

data/lib/rubype/version.rb

@@ -1,3 +1,3 @@
 module Rubype
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/rubype.rb

@@ -17,9 +17,9 @@ class Module
     *arg_types, type_pair = hash.values.first
 
     __rubype__.send(:define_method, meth) do |*args, &block|
-      ::Rubype.send(:assert_arg_type, meth, args, arg_types << type_pair.keys.first)
+      ::Rubype.send(:assert_arg_type, self, meth, args, arg_types << type_pair.keys.first)
       rtn = super(*args, &block)
-      ::Rubype.send(:assert_trn_type, meth, rtn, type_pair.values.first)
+      ::Rubype.send(:assert_trn_type, self, meth, rtn, type_pair.values.first)
       rtn
     end
     self
@@ -27,34 +27,52 @@ class Module
 end
 
 module Rubype
+  class ArgumentTypeError < ::TypeError; end
+  class ReturnTypeError   < ::TypeError; end
+
   class << self
     private
 
+    # @param caller [Module]
     # @param meth [Symbol]
     # @param args [Array<Object>]
-    # @param klasses [Array<Class>]
-    def assert_arg_type(meth, args, klasses)
+    # @param type_infos [Array<Class, Symbol>]
+    def assert_arg_type(caller, meth, args, type_infos)
       args.each_with_index do |arg, i|
-        if wrong_type?(arg, klasses[i])
-          raise ArgumentError, "Wrong type of argument, type of #{arg.inspect} should be #{klasses[i]}"
+        case type_check(arg, type_infos[i])
+        when :need_correct_class
+          raise ArgumentTypeError,
+            "Expected #{caller.class}##{meth}'s #{i+1}th argument to be #{type_infos[i]} but got #{arg.inspect} instead"
+        when :need_correct_method
+          raise ArgumentTypeError,
+            "Expected #{caller.class}##{meth}'s #{i+1}th argument to have method ##{type_infos[i]} but got #{arg.inspect} instead"
         end
       end
     end
 
-    # @param meth [Symbol]
+    # @param caller [Module]
     # @param rtn [Object]
-    # @param klass [Class]
-    def assert_trn_type(meth, rtn, klass)
-      if wrong_type?(rtn, klass)
-        raise TypeError, "Expected #{meth} to return #{klass} but got #{rtn.inspect} instead"
+    # @param type_info [Class, Symbol]
+    def assert_trn_type(caller, meth, rtn, type_info)
+      case type_check(rtn, type_info)
+      when :need_correct_class
+        raise ReturnTypeError,
+          "Expected #{caller.class}##{meth} to return #{type_info} but got #{rtn.inspect} instead"
+      when :need_correct_method
+        raise ReturnTypeError,
+          "Expected #{caller.class}##{meth} to have method ##{type_info} but got #{rtn.inspect} instead"
       end
     end
 
     # @param obj [Object]
-    # @param klass [Class]
-    # @return [Boolean]
-    def wrong_type?(obj, klass)
-      !(obj.is_a?(klass) || klass == Any)
+    # @param type_info [Class, Symbol]
+    # @return [Symbol]
+    def type_check(obj, type_info)
+      if type_info.is_a?(Module) && !(obj.is_a?(type_info) || type_info == Any)
+        :need_correct_class
+      elsif type_info.is_a?(Symbol) && !(obj.respond_to?(type_info))
+        :need_correct_method
+      end
     end
   end
 end

data/test/test_rubype.rb

@@ -13,7 +13,7 @@ class TestRubype < MiniTest::Unit::TestCase
     @hash    = { test: :hash }
   end
 
-  def test_correct_type
+  def test_correct_type_by_class
     assert_correct_type [Numeric => Numeric], [@numeric], @numeric
     assert_correct_type [Numeric => Array  ], [@numeric], @array
     assert_correct_type [Numeric => String ], [@numeric], @string
@@ -29,6 +29,17 @@ class TestRubype < MiniTest::Unit::TestCase
     assert_correct_type [Boolean, Symbol  => Symbol ], [true, @symbol ], @symbol
   end
 
+  def test_correct_type_by_sym
+    assert_correct_type [Numeric => :to_i], [@numeric], @numeric
+    assert_correct_type [Numeric => :to_i], [@numeric], @string
+
+    assert_correct_type [Numeric => :to_s], [@numeric], @numeric
+    assert_correct_type [Numeric => :to_s], [@numeric], @string
+    assert_correct_type [Numeric => :to_s], [@numeric], @symbol
+    assert_correct_type [Numeric => :to_s], [@numeric], @array
+    assert_correct_type [Numeric => :to_s], [@numeric], @hash
+  end
+
   def test_wrong_return_type
     assert_wrong_rtn [Numeric => Numeric], [@numeric], @array
     assert_wrong_rtn [Numeric => Numeric], [@numeric], @string
@@ -41,6 +52,10 @@ class TestRubype < MiniTest::Unit::TestCase
     assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @hash
     assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @symbol
     assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], true
+
+    assert_wrong_rtn [Numeric => :to_i], [@numeric], @symbol
+    assert_wrong_rtn [Numeric => :to_i], [@numeric], @array
+    assert_wrong_rtn [Numeric => :to_i], [@numeric], @hash
   end
 
   def test_wrong_args_type
@@ -55,6 +70,11 @@ class TestRubype < MiniTest::Unit::TestCase
     assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @hash  ], @numeric
     assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @symbol], @numeric
     assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, true   ], @numeric
+
+    assert_wrong_arg [Numeric => :to_i], [@array ], @numeric
+    assert_wrong_arg [Numeric => :to_i], [@hash  ], @numeric
+    assert_wrong_arg [Numeric => :to_i], [@symbol], @numeric
+    assert_wrong_arg [Numeric => :to_i], [true   ], @numeric
   end
 
   def test_any
@@ -79,11 +99,11 @@ class TestRubype < MiniTest::Unit::TestCase
     end
 
     def assert_wrong_arg(type_list, args, val)
-      assert_raises(ArgumentError) { define_test_method(type_list, args, val).call(*args) }
+      assert_raises(Rubype::ArgumentTypeError) { define_test_method(type_list, args, val).call(*args) }
     end
 
     def assert_wrong_rtn(type_list, args, val)
-      assert_raises(TypeError) { define_test_method(type_list, args, val).call(*args) }
+      assert_raises(Rubype::ReturnTypeError) { define_test_method(type_list, args, val).call(*args) }
     end
 
     def define_test_method(type_list, args, val)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubype
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-07 00:00:00.000000000 Z
+date: 2014-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler