tspec 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a54636f321a831faea2655843bad6ce92b99fe65
-  data.tar.gz: aab6a5ebe27dd54bbbfd6a2002cc5fcb01034189
+  metadata.gz: 84d333dcb760ef858b22802125d730f1b92620e3
+  data.tar.gz: e584d70cc0359970c93dc0b5c4953a526a20720b
 SHA512:
-  metadata.gz: 1b5b2c4157f1656b8634add26ed21e442d65e871afd0d91e3daaf89ad31b0fd2d93c70879628c077713970b6fc987b1c369ac5fd9257cdf0f56fdc503bbf448b
-  data.tar.gz: fc291a4ed9f314232b7082c036b6917641cfa3ef802f13623ddb0c77e629f9b8d49061368cbef9d5e5761cd496af9e01a140d6acb6278f5be8b4feb75be43aac
+  metadata.gz: 89a5b92412920594c39e4ea503a693e82036bbec41ef4447e2d4520267af63192c83e1fd663cf66949f006623ce956f363ba5b74979e5fb4e4f27e87ed4e6646
+  data.tar.gz: dbe9ac78c9a44d35889114b8365aca4cfd8ec85f8c35bc34daa2609ed79bc87cc5febb31f73fa3b20ec2555c968b9ea1a7e97066ff3062df93cc7e4febf90425

data/lib/tspec/core.rb

@@ -0,0 +1,127 @@
+class Symbol
+  def return(*types)
+    self
+  end
+
+  def receive(*type, **types)
+    self
+  end
+end
+
+class UnboundMethod
+  def return(*types)
+    self
+  end
+
+  def receive(*type, **types)
+    self
+  end
+end
+
+class Method
+  def return(*types)
+    self
+  end
+
+  def receive(*type, **types)
+    self
+  end
+end
+
+module TSpec
+  module_function
+
+  def value_type_check(value, *types)
+    types.any? do |type|
+      if type.instance_of?(Array)
+        return false unless value.instance_of?(Array)
+
+        value.all? do |v|
+          type.any? do |t|
+            value_type_check(v, t)
+          end
+        end
+      else
+        value.instance_of?(type)
+      end
+    end
+  end
+
+  def regist_type(method_id, ctx, keys)
+    types = ctx.local_variable_get(:types)
+
+    case method_id
+      when :return
+        regist_return_type(keys, types)
+      when :receive
+        regist_receive_type(keys, types, ctx.local_variable_get(:type))
+    end
+  end
+
+  def get_keys(tp, btp)
+    ctx = tp.binding
+    keys = []
+
+    if %i(instance_method method).include?(btp[:method_id])
+      keys << "#{tp.self.owner}::#{tp.self.name}"
+    else
+      if btp[:method_id] == :singleton_method_added
+        klass = btp[:self].singleton_class
+
+        if @module_function_flags[btp[:self]]
+          keys << "#{btp[:self]}::#{ctx.receiver}"
+        end
+      else
+        klass = btp[:self]
+      end
+
+      keys << "#{klass}::#{ctx.receiver}"
+    end
+
+    keys
+  end
+
+  def regist_return_type(keys, types)
+    keys.each do |key|
+      @method_return_type_table[key] = types
+    end
+  end
+
+  def regist_receive_type(keys, types, type)
+    keys.each do |key|
+      @method_arguments_type_table[key] = types
+
+      if @method_arguments_type_table[key].empty?
+        @method_arguments_type_table[key] = { type.__id__ => type }
+      end
+    end
+  end
+
+  def check_type(tp)
+    key = "#{tp.defined_class}::#{tp.method_id}"
+
+    if types = @method_arguments_type_table[key]
+      arguments = tp.binding.eval("method(:#{tp.method_id}).parameters.map(&:last)")
+
+      types.each do |name, type|
+        name = arguments.first if name == type.__id__
+
+        unless arguments.include?(name)
+          @type_error_flag = true
+          raise NotFoundArgumentNameError, "undefined arguments `#{name}' for #{key}"
+        end
+
+        value = tp.binding.local_variable_get(name)
+
+        unless value_type_check(value, *type)
+          @type_error_flag = true
+          if type.instance_of?(Array)
+            raise ArgumentTypeError, "##{tp.method_id} '#{name}' variable should be #{type.map(&:inspect).join(' or ')}, but actual '#{value.inspect}' - #{value.class}"
+          else
+            raise ArgumentTypeError, "##{tp.method_id} '#{name}' variable should be #{type.inspect}, but actual '#{value.inspect}' - #{value.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tspec/version.rb

@@ -0,0 +1,3 @@
+module TSpec
+  VERSION = '0.4.0'
+end

data/lib/tspec.rb

@@ -1,125 +1,74 @@
+require 'tspec/version'
 require 'tspec/type_error'
-
-class Symbol
-  def return(*types)
-    self
-  end
-
-  def receive(*type, **types)
-    self
-  end
-end
-
-class UnboundMethod
-  def return(*types)
-    self
-  end
-
-  def receive(*type, **types)
-    self
-  end
-end
-
-class Method
-  def return(*types)
-    self
-  end
-
-  def receive(*type, **types)
-    self
-  end
-end
+require 'tspec/core'
 
 module TSpec
   @method_return_type_table = {}
   @method_arguments_type_table = {}
   @before_trace = {}
+  @module_function_flags = {}
+  @module_function_mode = {}
   @type_error_flag = false
+  HOOK_EVENT = %i(call return c_call c_return line)
   DEFINE_METHOD_SYMBOLS = %i(method_added singleton_method_added define_method instance_method method)
 
-  def self.value_type_check(value, *types)
-    types.any? do |type|
-      if type.instance_of?(Array)
-        return false unless value.instance_of?(Array)
-
-        value.all? do |v|
-          type.any? do |t|
-            value_type_check(v, t)
-          end
-        end
-      else
-        value.instance_of?(type)
-      end
-    end
-  end
-
-  TracePoint.trace do |tp|
-    case tp.event
-      when :call
-        if %i(return receive).include?(tp.method_id) && DEFINE_METHOD_SYMBOLS.include?(@before_trace[:method_id])
-          ctx = tp.binding
-
-          if %i(instance_method method).include?(@before_trace[:method_id])
-            key = "#{tp.self.owner}::#{tp.self.name}"
+  @trace = TracePoint.new(*HOOK_EVENT) do |tp|
+    @trace.disable do
+      case tp.event
+        when :call
+          if %i(return receive).include?(tp.method_id) && DEFINE_METHOD_SYMBOLS.include?(@before_trace[:method_id])
+            ctx = tp.binding
+            keys = get_keys(tp, @before_trace)
+            regist_type(tp.method_id, ctx, keys)
           else
-            klass = (@before_trace[:method_id] == :singleton_method_added) ? @before_trace[:self].singleton_class : @before_trace[:self]
-            key = "#{klass}::#{ctx.receiver}"
-          end
-
-          case tp.method_id
-            when :return
-              @method_return_type_table[key] = ctx.local_variable_get(:types)
-            when :receive
-              @method_arguments_type_table[key] = ctx.local_variable_get(:types)
-
-              if @method_arguments_type_table[key].empty?
-                @method_arguments_type_table[key] = {ctx.local_variable_get(:type).__id__ => ctx.local_variable_get(:type)}
-              end
+            check_type(tp)
           end
-        else
-          key = "#{tp.defined_class}::#{tp.method_id}"
-
-          if types = @method_arguments_type_table[key]
-            arguments = tp.binding.eval("method(:#{tp.method_id}).parameters.map(&:last)")
-
-            types.each do |name, type|
-              name = arguments.first if name == type.__id__
+        when :c_call
+          if tp.method_id == :module_function && tp.defined_class == Module
+            @module_function_mode[tp.self] = true
 
-              unless arguments.include?(name)
-                @type_error_flag = true
-                raise NotFoundArgumentNameError, "undefined arguments `#{name}' for #{key}"
-              end
+            line = File.readlines(tp.path)[tp.lineno-1]
+            names = line.scan(/:.+/)
 
-              value = tp.binding.local_variable_get(name)
+            if names.empty?
+              @module_function_flags[tp.self] = true
+            else
+              names.each do |name|
+                key = "#{tp.self}:#{name}"
 
-              unless value_type_check(value, *type)
-                @type_error_flag = true
-                if type.instance_of?(Array)
-                  raise ArgumentTypeError, "##{tp.method_id} '#{name}' variable should be #{type.map(&:inspect).join(' or ')}, but actual '#{value.inspect}' - #{value.class}"
-                else
-                  raise ArgumentTypeError, "##{tp.method_id} '#{name}' variable should be #{type.inspect}, but actual '#{value.inspect}' - #{value.class}"
+                if type = @method_return_type_table[key]
+                  @method_return_type_table["#{tp.self.singleton_class}:#{name}"] = type
+                end
+                if type = @method_arguments_type_table[key]
+                  @method_arguments_type_table["#{tp.self.singleton_class}:#{name}"] = type
                 end
               end
             end
           end
-        end
-      when :return
-        if !@type_error_flag
-          key = "#{tp.defined_class}::#{tp.method_id}"
+        when :c_return
+          if tp.method_id == :module_function && tp.defined_class == Module
+            @module_function_mode[tp.self] = false
+          end
+        when :return
+          if !@type_error_flag
+            key = "#{tp.defined_class}::#{tp.method_id}"
 
-          if types = @method_return_type_table[key]
-            unless value_type_check(tp.return_value, *types)
-              @type_error_flag = true
-              raise ReturnValueTypeError, "`#{tp.method_id}' expected return #{types.map(&:inspect).join(' or ')}, but actual `#{tp.return_value.inspect}' - #{tp.return_value.class}"
+            if types = @method_return_type_table[key]
+              unless value_type_check(tp.return_value, *types)
+                @type_error_flag = true
+                raise ReturnValueTypeError, "`#{tp.method_id}' expected return #{types.map(&:inspect).join(' or ')}, but actual `#{tp.return_value.inspect}' - #{tp.return_value.class}"
+              end
             end
           end
-        end
-    end
+      end
 
-    @type_error_flag = false
+      @type_error_flag = false
 
-    if tp.defined_class != Symbol || !%i(return receive).include?(tp.method_id)
-      @before_trace = {self: tp.self, method_id: tp.method_id}
+      if tp.defined_class != Symbol || !%i(return receive).include?(tp.method_id)
+        @before_trace = { self: tp.self, method_id: tp.method_id }
+      end
     end
   end
+
+  @trace.enable
 end

data/tspec.gemspec

@@ -2,9 +2,11 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
+require 'tspec/version'
+
 Gem::Specification.new do |spec|
   spec.name          = "tspec"
-  spec.version       = "0.3.0"
+  spec.version       = TSpec::VERSION
   spec.authors       = ["siman-man"]
   spec.email         = ["k128585@ie.u-ryukyu.ac.jp"]
 
@@ -25,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "coderay", "~> 1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tspec
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - siman-man
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: Add type check method
 email:
 - k128585@ie.u-ryukyu.ac.jp
@@ -74,7 +88,9 @@ files:
 - examples/return_failed.rb
 - examples/return_success.rb
 - lib/tspec.rb
+- lib/tspec/core.rb
 - lib/tspec/type_error.rb
+- lib/tspec/version.rb
 - tspec.gemspec
 homepage: https://github.com/siman-man/tspec
 licenses: