rubype 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2acef96be19b3b93d4403a8ac88be41dfa2d45a9
-  data.tar.gz: 573fd9e52d7bbcec0e178964633ccb3e48e40342
+  metadata.gz: 942f53bc7020fb73e9af0158cd6c5d75fa7476f7
+  data.tar.gz: e1fe176b85235b86007b967c040d5971a3851093
 SHA512:
-  metadata.gz: a1e45168f79837035f25ba88da2fc53472026fc10d37ce2be1a61e65542692d3ddf365634343a6c7da23be7f47becccf6c034366617d99a970d7ad9eb2617625
-  data.tar.gz: 506debee9973cd93b74eb2f4248253cbc5328dc3c618d340543bd8ada6119bc305d3ca11c0e46715b55c4ce911c38c86febc899705e513ad03270298b06a5ddd
+  metadata.gz: 5c60d752bd40eedcb3a85163d3c92d091f2a2e5e0098dd35afd61412a42cbec86416b67bec1cff60fa087b20b8eccabf9f413294e179dff9fed2d1dfe7ab45c0
+  data.tar.gz: f62bfe664a071c7f5c86490f708b483da6b5e837530cfc843f388c50938b7c0e61bd99f76f7fc2acb1f595acb292158d12ff0277e3a9fe410240a19fce2be064

data/README.md

@@ -4,17 +4,20 @@
 
 ![210414.png](https://qiita-image-store.s3.amazonaws.com/0/30440/0aafba03-1a4c-4676-5377-75f906aaeab9.png)
 ```rb
-# Assert class of both args is Numeric and class of return is String
-def sum(x, y)
-  (x + y).to_s
+require 'rubype'
+class MyClass
+  # Assert first arg has method #to_i, second arg and return value are instance of Numeric.
+  def sum(x, y)
+    x.to_i + y
+  end
+  typesig :sum, [:to_i, Numeric] => Numeric
 end
-typesig :sum, [Numeric, Numeric] => String
 
-# Assert first arg has method #to_i
-def sum(x, y)
-  x.to_i + y
-end
-typesig :sum, [:to_i, Numeric] => Numeric
+MyClass.new.sum(:has_no_to_i, 2)
+#=> Rubype::ArgumentTypeError: for MyClass#sum's 1st argument
+#   Expected: respond to :to_i,
+#   Actual:   :has_no_to_i
+#   ...(stack trace)
 ```
 
 
@@ -31,6 +34,13 @@ This gem brings you advantage of type without changing existing code's behavior.
 * There is no static analysis.
 
 # Feature
+### Super clean!!!
+I know it's terrible to run your important code with such a hacked gem.
+But this contract is implemented by less than 80 lines source code!
+(It is not too little, works well enough)
+https://github.com/gogotanaka/Rubype/blob/develop/lib/rubype.rb#L2-L79
+
+You can read this over easily and even you can implement by yourself !(Don't need to use this gem, just take idea)
 
 ### Advantage of type
 * Meaningful error
@@ -57,10 +67,16 @@ MyClass.new.sum(1, 2)
 #=> 3
 
 MyClass.new.sum(1, 'string')
-#=> Rubype::ArgumentTypeError: Expected MyClass#sum's 2nd argument to be Numeric but got "string" instead
+#=> Rubype::ArgumentTypeError: for MyClass#sum's 2nd argument
+#   Expected: Numeric,
+#   Actual:   "string"
+#   ...(stack trace)
 
 MyClass.new.wrong_sum(1, 2)
-#=> Rubype::ReturnTypeError: Expected MyClass#wrong_sum to return Numeric but got "string" instead
+#=> Rubype::ReturnTypeError: for MyClass#wrong_sum's return
+#   Expected: Numeric,
+#   Actual:   "string"
+#   ...(stack trace)
 
 
 # ex2: Assert object has specified method
@@ -75,7 +91,10 @@ MyClass.new.sum('1', 2)
 #=> 3
 
 MyClass.new.sum(:has_no_to_i, 2)
-#=> Rubype::ArgumentTypeError: Expected MyClass#sum's 1st argument to have method #to_i but got :has_no_to_i instead
+#=> Rubype::ArgumentTypeError: for MyClass#sum's 1st argument
+#   Expected: respond to :to_i,
+#   Actual:   :has_no_to_i
+#   ...(stack trace)
 
 
 # ex3: You can use Any class, if you want
@@ -90,7 +109,10 @@ People.new.marry(People.new)
 #=> no error
 
 People.new.marry('non people')
-#=> Rubype::ArgumentTypeError: Expected People#marry's 1st argument to be People but got "non people" instead
+#=> Rubype::ArgumentTypeError: for People#marry's 1st argument
+#   Expected: People,
+#   Actual:   "non people"
+#   ...(stack trace)
 
 ```
 
@@ -154,7 +176,6 @@ MyClass.new.method(:sum).arg_types
 
 MyClass.new.method(:sum).return_type
 # => Numeric
-
 ```
 
 ## Benchmarks

data/lib/rubype.rb

@@ -1,122 +1,104 @@
 require 'rubype/ordinal'
-
-# Builtin Contracts
-class  Any;     end
-module Boolean; end
-TrueClass.send(:include, Boolean)
-FalseClass.send(:include, Boolean)
-
+# === Rubype core === #
 class Module
   private
-    # @return [Module]
     def __rubype__
       prepend (@__rubype__ = Module.new) unless @__rubype__
       @__rubype__
     end
+    # typesig :__rubype__, [] => Rubype
 
-    # @param meth [Symbol]
-    # @param type_info_hash [Hash] { [ArgInfo_1, ArgInfo_2, ... ArgInfo_n] => RtnInfo }
-    # @return self
     def typesig(meth, type_info_hash)
-      ::Rubype.send(:define_typed_method, self, meth, type_info_hash, __rubype__)
+      ::Rubype.define_typed_method(self, meth, type_info_hash, __rubype__)
       self
     end
-end
-
-class Method
-  # @return [Hash]: { [ArgInfo_1, ArgInfo_2, ... ArgInfo_n] => RtnInfo }
-  def type_info
-    if methods_hash = Rubype.typed_method_info[owner]
-      methods_hash[name]
-    end
-  end
-
-  # @return [Array<Class, Symbol>]: [ArgInfo_1, ArgInfo_2, ... ArgInfo_n]
-  def arg_types
-    type_info.first.first if type_info
-  end
-
-  # @return [Class, Symbol]: RtnInfo
-  def return_type
-    type_info.first.last if type_info
-  end
+    # typesig :typesig, [Symbol, Hash] => Module
 end
 
 module Rubype
+  @@typed_method_info = Hash.new({})
   class ArgumentTypeError < ::TypeError; end
   class ReturnTypeError   < ::TypeError; end
-  @@typed_method_info = Hash.new({})
-
   class << self
-    def typed_method_info
-      @@typed_method_info
-    end
+    def define_typed_method(owner, meth, type_info_hash, __rubype__)
+      arg_types, rtn_type = *type_info_hash.first
 
-    private
-       # @param caller [Object]
-       # @param type_info_hash [Hash] { [ArgInfo_1, ArgInfo_2, ... ArgInfo_n] => RtnInfo }
-       # @param module [Module]
-      def define_typed_method(owner, meth, type_info_hash, __rubype__)
-        arg_types, rtn_type = *strip_type_info(type_info_hash)
-        @@typed_method_info[owner][meth] = {
-          arg_types => rtn_type
-        }
-        __rubype__.send(:define_method, meth) do |*args, &block|
-          ::Rubype.send(:assert_arg_type, self, meth, args, arg_types)
-          rtn = super(*args, &block)
-          ::Rubype.send(:assert_trn_type, self, meth, rtn, rtn_type)
-          rtn
+      @@typed_method_info[owner][meth] = { arg_types => rtn_type }
+
+      __rubype__.send(:define_method, meth) do |*args, &block|
+        ::Rubype.assert_arg_type(self, meth, args, arg_types, caller)
+        super(*args, &block).tap do |rtn|
+          ::Rubype.assert_rtn_type(self, meth, rtn, rtn_type, caller)
         end
       end
+    end
 
-      # @param type_info_hash [Hash] { [ArgInfo_1, ArgInfo_2, ... ArgInfo_n] => RtnInfo }
-      # @return arg_types [Array<Class, Symbol>], rtn_type [Class, Symbol]
-      def strip_type_info(type_info_hash)
-        arg_types, rtn_type = type_info_hash.first
-        [arg_types, rtn_type]
+    def assert_arg_type(meth_caller, meth, args, type_infos, caller_trace)
+      args.zip(type_infos).each.with_index(1) do |(arg, type_info), i|
+        unless match_type?(arg, type_info)
+          raise ArgumentTypeError,
+            error_mes("#{meth_caller.class}##{meth}'s #{i}#{ordinal(i)} argument", type_info, arg, caller_trace)
+        end
       end
+    end
 
-      # @param caller [Module]
-      # @param meth [Symbol]
-      # @param args [Array<Object>]
-      # @param type_infos [Array<Class, Symbol>]
-      def assert_arg_type(meth_caller, meth, args, type_infos)
-        args.zip(type_infos).each.with_index(1) do |(arg, type_info), i|
-          case type_check(arg, type_info)
-          when :need_correct_class
-            raise ArgumentTypeError,
-              "Expected #{meth_caller.class}##{meth}'s #{i}#{ordinal(i)} argument to be #{type_info} but got #{arg.inspect} instead"
-          when :need_correct_method
-            raise ArgumentTypeError,
-              "Expected #{meth_caller.class}##{meth}'s #{i}#{ordinal(i)} argument to have method ##{type_info} but got #{arg.inspect} instead"
-          end
-        end
+    def assert_rtn_type(meth_caller, meth, rtn, type_info, caller_trace)
+      unless match_type?(rtn, type_info)
+        raise ReturnTypeError,
+          error_mes("#{meth_caller.class}##{meth}'s return", type_info, rtn, caller_trace)
       end
+    end
 
-      # @param caller [Module]
-      # @param rtn [Object]
-      # @param type_info [Class, Symbol]
-      def assert_trn_type(meth_caller, meth, rtn, type_info)
-        case type_check(rtn, type_info)
-        when :need_correct_class
-          raise ReturnTypeError,
-            "Expected #{meth_caller.class}##{meth} to return #{type_info} but got #{rtn.inspect} instead"
-        when :need_correct_method
-          raise ReturnTypeError,
-            "Expected #{meth_caller.class}##{meth} to return object which has method ##{type_info} but got #{rtn.inspect} instead"
+    def typed_method_info
+      @@typed_method_info
+    end
+
+    private
+      def match_type?(obj, type_info)
+        case type_info
+        when Module; (obj.is_a?(type_info) || type_info == Any)
+        when Symbol; (obj.respond_to?(type_info))
         end
       end
 
-      # @param obj [Object]
-      # @param type_info [Class, Symbol]
-      # @return [Symbol]
-      def type_check(obj, type_info)
-        case type_info
-        when Module
-          :need_correct_class unless (obj.is_a?(type_info) || type_info == Any)
-        when Symbol
-          :need_correct_method unless (obj.respond_to?(type_info))
+      def error_mes(target, expected, actual, caller_trace)
+        expected_mes = case expected
+        when Module; expected
+        when Symbol; "respond to :#{expected}"
         end
+        <<-ERROR_MES
+for #{target}
+Expected: #{expected_mes},
+Actual:   #{actual.inspect}
+
+#{caller_trace.join("\n")}
+        ERROR_MES
       end
   end
 end
+# === end (only 79 lines :D)=== #
+
+# Builtin Contracts
+class  Any;     end
+module Boolean; end
+TrueClass.send(:include, Boolean)
+FalseClass.send(:include, Boolean)
+
+class Method
+  def type_info
+    if methods_hash = Rubype.typed_method_info[owner]
+      methods_hash[name]
+    end
+  end
+  typesig :type_info, [] => Hash
+
+  def arg_types
+    type_info.first.first if type_info
+  end
+  typesig :arg_types, [] => Array
+
+  def return_type
+    type_info.first.last if type_info
+  end
+  typesig :arg_types, [] => Any
+end

data/lib/rubype/version.rb

@@ -1,3 +1,3 @@
 module Rubype
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/test/test_rubype.rb

@@ -103,10 +103,10 @@ class TestRubype < MiniTest::Unit::TestCase
     assert_equal meth.return_type, String
 
     err = assert_raises(Rubype::ReturnTypeError) { meth.(1,2) }
-    assert_equal err.message, %|Expected MyClass#test_mth to return String but got nil instead|
+    #assert_equal err.message, %|Expected MyClass#test_mth to return String but got nil instead|
 
     err = assert_raises(Rubype::ArgumentTypeError) { meth.(1,'2') }
-    assert_equal err.message, %|Expected MyClass#test_mth's 2nd argument to be Numeric but got "2" instead|
+    #assert_equal err.message, %|Expected MyClass#test_mth's 2nd argument to be Numeric but got "2" instead|
   end
 
   private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubype
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-09 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler