argtrace 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7398f53bb9b94105fc990221979803eaceebffa073e7487b16b558fc65755af6
+  data.tar.gz: 0744ce1ba76244daf8d442465e6ac7828cdf07b51f486b4b661c619f333419cb
+SHA512:
+  metadata.gz: 274187675f07b8141b2ddbf05be0d344d5ce885cfc945c0d76912b2b77acfcba447eedaa1cc0dba0b671d1dee8b1dbe79fc4772b1747a8f946952a98749ce5f4
+  data.tar.gz: 3e05fa0e9067ec243aca02b4e94a016e9e193cd26d0bd321295dd1c8159926f7a48274eaee52d85121ca60eeb9d5b3dcfef7505f4ddc13fba74c6cd894c0f991

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+/.vscode/

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in argtrace.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "rubocop", "~> 0.80"
+
+gem "ruby-debug-ide"
+gem "debase"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Riki Ishikawa
+
+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,53 @@
+# Argtrace
+
+Argtrace is a Ruby MRI method type analyser.
+
+Argtrace uses TracePoint and traces all of method calling,
+peeks actual type of parameters and return value,
+and finally summarize them into RBS format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'argtrace'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install argtrace
+
+## Usage
+
+### 1. Explicit trace
+```ruby
+require 'argtrace'
+Argtrace::Default.main(rbs_path: "sig.rbs")
+
+... (YOUR PROGRAM HERE) ...
+```
+RBS file is saved as "sig.rbs" in current directory.
+
+### 2. Implicit trace
+```console
+$ ruby -r argtrace/autorun  YOUR_PROGRAM_HERE.rb
+```
+RBS file is saved as "sig.rbs" in current directory.
+
+### Restriction
+Argtrace cannot work with C-extension,
+because TracePoint doesn't provide feature to access arguments of calls into C-extension.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jljse/argtrace.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/argtrace.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/argtrace/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "argtrace"
+  spec.version       = Argtrace::VERSION
+  spec.authors       = ["Riki Ishikawa"]
+  spec.email         = ["riki.ishikawa@gmail.com"]
+
+  spec.summary       = "trace arguments of method calls or block calls."
+  spec.description   = "library to trace arguments of method calls or block calls with TracePoint and do callback."
+  spec.homepage      = "https://github.com/jljse/argtrace/"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/jljse/argtrace/"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "argtrace"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/argtrace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "argtrace/version"
+require_relative "argtrace/signature.rb"
+require_relative "argtrace/tracer.rb"
+require_relative "argtrace/typelib.rb"
+require_relative "argtrace/default.rb"
+
+module Argtrace
+  class ArgtraceError < StandardError; end
+end
+

data/lib/argtrace/autorun.rb

@@ -0,0 +1,3 @@
+require_relative '../argtrace.rb'
+
+Argtrace::Default.main()

data/lib/argtrace/default.rb

@@ -0,0 +1,32 @@
+module Argtrace
+  # Default tracing setting.
+  class Default
+    # Default tracing setting. Analyse only user sources, and output them into RBS file.
+    def self.main(rbs_path: "sig.rbs")
+      typelib = Argtrace::TypeLib.new
+      tracer = Argtrace::Tracer.new
+
+      tracer.set_filter do |tp|
+        if [:call, :return].include?(tp.event)
+          tracer.user_source?(tp.defined_class, tp.method_id)
+        else
+          true
+        end
+      end
+
+      tracer.set_notify do |ev, callinfo|
+        if ev == :return
+          typelib.learn(callinfo.signature)
+        end
+      end
+
+      tracer.set_exit do
+        File.open(rbs_path, "w") do |f|
+          f.puts typelib.to_rbs
+        end
+      end
+
+      tracer.start_trace
+    end
+  end
+end

data/lib/argtrace/signature.rb

@@ -0,0 +1,233 @@
+
+module Argtrace
+
+  # signature of method/block 
+  class Signature
+    attr_accessor :defined_class, :method_id, :is_singleton_method, :params, :return_type
+
+    def initialize
+      @is_singleton_method = false
+      @params = []
+    end
+
+    def merge(all_params, ret)
+      unless @params
+        @params = []
+      end
+      # all params (including optional / keyword etc)
+      for i in 0...all_params.size
+        if i == @params.size
+          @params << all_params[i]  # TODO: dup
+        else
+          if @params[i].mode == all_params[i].mode &&
+              @params[i].name == all_params[i].name
+            if all_params[i].mode == :block
+              # TODO: buggy
+              # merging of block parameter type is quite tricky...
+              @params[i].type.merge(
+                all_params[i].type.params, nil)
+            else
+              @params[i].type.merge_union(all_params[i].type)
+            end
+          else
+            raise "signature change not supported"
+          end
+        end
+      end
+
+      if ret
+        unless @return_type
+          @return_type = TypeUnion.new
+        end
+        @return_type.merge_union(ret)
+      end
+    end
+
+    def get_block_param
+      @params.find{|x| x.mode == :block}
+    end
+
+    def to_s
+      "Signature(#{@defined_class}::#{@method_id}(" + @params.map{|x| x.to_s}.join(",") + ") => #{@return_type.to_s})"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # instance for one parameter
+  class Parameter
+    attr_accessor :mode, :name, :type
+
+    def hash
+      [@mode, @name, @type].hash
+    end
+
+    def to_s
+      "Parameter(#{@name}@#{@mode}:#{@type.to_s})"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # Union of types (e.g. String | Integer)
+  class TypeUnion
+    attr_accessor :union;
+
+    def initialize
+      @union = []
+    end
+
+    def merge_union(other_union)
+      other_union.union.each do |type|
+        self.add(type)
+      end
+    end
+
+    def add(type)
+      for i in 0...@union.size
+        if @union[i] == type
+          # already in union
+          return
+        end
+        if @union[i].superclass_of?(type)
+          # already in union
+          return
+        end
+        if type.superclass_of?(@union[i])
+          # remove redundant element
+          @union[i] = nil
+        end
+      end
+      @union.compact!
+      @union << type
+      self
+    end
+
+    def to_s
+      if @union.empty?
+        "TypeUnion(None)"
+      else
+        "TypeUnion(" + @union.map{|x| x.to_s}.join("|") + ")"
+      end
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # placeholder for TrueClass / FalseClass
+  class BooleanClass
+  end
+
+  # type in RBS manner
+  class Type
+    attr_accessor :data, :subdata
+
+    def initialize()
+      @data = nil
+      @subdata = nil
+    end
+
+    def self.new_with_type(actual_type)
+      ret = Type.new
+      if actual_type == TrueClass || actual_type == FalseClass
+        ret.data = BooleanClass
+      else
+        ret.data = actual_type
+      end
+      return ret
+    end
+
+    def self.new_with_value(actual_value)
+      ret = Type.new
+      if actual_value.is_a?(Symbol)
+        # use symbol as type
+        ret.data = actual_value
+      elsif true == actual_value || false == actual_value
+        # warn: operands of == must in this order, because of override.
+        # treat true and false as boolean
+        ret.data = BooleanClass
+      elsif actual_value.class == Array
+        # TODO: multi type array
+        ret.data = Array
+        unless actual_value.empty?
+          if true == actual_value.first || false == actual_value.first
+            ret.subdata = BooleanClass
+          else
+            ret.subdata = actual_value.first.class
+          end
+        end
+      else
+        ret.data = actual_value.class
+      end
+      return ret
+    end
+
+    def hash
+      @data.hash
+    end
+
+    def ==(other)
+      if other.class != Type
+        return false
+      end
+      return @data == other.data && @subdata == other.subdata
+    end
+
+    def eql?(other)
+      self.==(other)
+    end
+
+    # true if self(Type) includes other(Type) as type declaration
+    # false if self and other is same Type.
+    def superclass_of?(other)
+      if other.class != Type
+        raise TypeError, "parameter must be Argtrace::Type"
+      end
+      if @data.is_a?(Symbol)
+        return false
+      elsif other.data.is_a?(Symbol)
+        return false
+      elsif @data == Array && other.data == Array
+        # TODO: merge for Array type like:
+        #   Array[X] | Array[Y]  =>  Array[X|Y]
+        if @subdata
+          if other.subdata
+            return other.subdata < @subdata
+          else
+            return true
+          end
+        else
+          # if self Array is untyped, cannot replace other as declaration.
+          return false
+        end
+      else
+        return other.data < @data
+      end
+    end
+
+    def to_s
+      if @data.is_a?(Symbol)
+        @data.inspect
+      elsif @data == Array
+        if @subdata
+          "Array[#{@subdata}]"
+        else
+          @data
+        end
+      else
+        @data.to_s
+      end
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+end

data/lib/argtrace/tracer.rb

@@ -0,0 +1,467 @@
+require 'pathname'
+
+module Argtrace
+
+  # instance per method/block call
+  class CallInfo
+    attr_accessor :signature
+
+    # actual block instance
+    attr_accessor :block_proc
+  end
+
+  # call stack of tracing targets
+  class CallStack
+    def initialize
+      # thread.object_id => stack
+      @stack = Hash.new{|h,k| h[k] = []}
+    end
+  
+    def push_callstack(callinfo)
+      id = Thread.current.object_id
+      # DEBUG:
+      # p "[#{id}]>>" + " "*@stack[id].size*2 + callinfo.signature.to_s
+
+      @stack[id].push callinfo
+    end
+  
+    def pop_callstack(tp)
+      id = Thread.current.object_id
+      ent = @stack[id].pop
+      if ent
+        # DEBUG:
+        # p "[#{id}]<<" + " "*@stack[id].size*2 + ent.signature.to_s
+
+        if tp.method_id != ent.signature.method_id
+          raise <<~EOF
+            callstack is broken
+            returning by tracepoint: #{tp.defined_class}::#{tp.method_id}
+            top of stack: #{ent.signature.to_s}
+            rest of stack:
+              #{@stack[id].map{|x| x.signature.to_s}.join("\n  ")}
+          EOF
+        end
+        type = TypeUnion.new
+        type.add(Type.new_with_value(tp.return_value))
+        ent.signature.return_type = type
+      end
+      return ent
+    end
+
+    # find callinfo which use specific block
+    def find_by_block_location(path, lineno)
+      id = Thread.current.object_id
+      ret = []
+      @stack[id].each do |info|
+        if info.block_proc && info.block_proc.source_location == [path, lineno]
+          ret << info
+        end
+      end
+      return ret
+    end
+  end
+
+  # class definition related operation and result caching.
+  class DefinitionResolver
+    def initialize
+      # TODO:      
+    end
+  end
+
+  # Main class for tracing with TracePoint.
+  class Tracer
+    attr_accessor :is_dead
+
+    def initialize()
+      @notify_block = nil
+      @callstack = CallStack.new
+      @tp_holder = nil
+      @is_dead = false
+
+      # prune_event_count > 0 while no need to notify.
+      # This is used to avoid undesirable signature lerning caused by error test.
+      @prune_event_count = 0
+
+      # cache of singleton-class => basic-class
+      @singleton_class_map_cache = {}
+
+      # cache of method location (klass => method_id => source_path)
+      @method_location_cache = Hash.new{|h, klass| h[klass] = {}}
+
+      # cache of judge result whether method is library-defined or user-defined
+      @ignore_paths_cache = {}
+    end
+
+    # entry point of trace event
+    def trace(tp)
+      if ignore_event?(tp)
+        return
+      end
+
+      if [:b_call, :b_return].include?(tp.event)
+        trace_block_event(tp)
+      else
+        trace_method_event(tp)
+      end
+    end
+
+    # process block call/return event
+    def trace_block_event(tp)
+      # I cannot determine the called block instance directly, so use block's location.
+      callinfos_with_block = @callstack.find_by_block_location(tp.path, tp.lineno)
+      callinfos_with_block.each do |callinfo|
+        block_param = callinfo.signature.get_block_param
+        block_param_types = get_param_types(callinfo.block_proc.parameters, tp)
+        # TODO: return type (but maybe, there is no demand)
+        block_param.type.merge(block_param_types, nil)
+      end
+    end
+
+    # process method call/return event
+    def trace_method_event(tp)
+      if [:call, :c_call].include?(tp.event)
+        # I don't know why but tp.parameters is different from called_method.parameters
+        # and called_method.parameters not work.
+        # called_method = get_called_method(tp)
+
+        case check_event_filter(tp)
+        when :prune
+          @prune_event_count += 1
+          skip_flag = true
+        when false
+          skip_flag = true
+        end
+
+        callinfo = CallInfo.new
+        signature = Signature.new
+        signature.defined_class = non_singleton_class(tp.defined_class)
+        signature.method_id = tp.method_id
+        signature.is_singleton_method = tp.defined_class.singleton_class?
+        signature.params = get_param_types(tp.parameters, tp)
+        callinfo.signature = signature
+        callinfo.block_proc = get_block_param_value(tp.parameters, tp)
+
+        @callstack.push_callstack(callinfo)
+
+        if !skip_flag && @prune_event_count == 0
+          # skip if it's object specific method
+          @notify_block.call(tp.event, callinfo) if @notify_block
+        end
+      else
+        case check_event_filter(tp)
+        when :prune
+          @prune_event_count -= 1
+          skip_flag = true
+        when false
+          skip_flag = true
+        end
+
+        callinfo = @callstack.pop_callstack(tp)
+        if callinfo
+          if !skip_flag && @prune_event_count == 0
+            @notify_block.call(tp.event, callinfo) if @notify_block
+          end
+        end
+      end
+    end
+
+    def standard_lib_root_path
+      # Search for standard lib path by some method location.
+      # I choose Pathname#parent here.
+      path = get_location(Pathname, :parent)
+      lib_dir = File.dirname(path)
+      return lib_dir
+    end
+
+    # true if method is defined in user source
+    def user_source?(klass, method_id)
+      path = get_location(klass, method_id)
+      return false unless path
+
+      unless @ignore_paths_cache.key?(path)
+        if path.start_with?("<internal:")
+          # skip all ruby internal method
+          @ignore_paths_cache[path] = true
+        elsif path == "(eval)"
+          # skip all eval
+          @ignore_paths_cache[path] = true
+        elsif path.start_with?(standard_lib_root_path())
+          # skip all standard lib
+          @ignore_paths_cache[path] = true
+        elsif Gem.path.any?{|x| path.start_with?(x)}
+          # skip all installed gem files
+          @ignore_paths_cache[path] = true
+        else
+          @ignore_paths_cache[path] = false
+        end
+      end
+      return ! @ignore_paths_cache[path]
+    end
+
+    def get_location(klass, method_id)
+      unless @method_location_cache[klass].key?(method_id)
+        path = nil
+        m = klass.instance_method(method_id)
+        if m and m.source_location
+          path = m.source_location[0]
+        end
+        @method_location_cache[klass][method_id] = path
+      end
+
+      return @method_location_cache[klass][method_id]
+    end
+
+    # true if klass is defined under Module
+    def under_module?(klass, mod)
+      ks = non_singleton_class(klass).to_s
+      ms = mod.to_s
+      return ks == ms || ks.start_with?(ms + "::")
+    end
+
+    # convert singleton class (like #<Class:Regexp>) to non singleton class (like Regexp)
+    def non_singleton_class(klass)
+      unless klass.singleton_class?
+        return klass
+      end
+
+      if /^#<Class:([A-Za-z0-9_:]+)>$/ =~ klass.inspect
+        # maybe normal name class
+        klass_name = Regexp.last_match[1]
+        begin
+          ret_klass = klass_name.split('::').inject(Kernel){|nm, sym| nm.const_get(sym)}
+        rescue => e
+          $stderr.puts "----- argtrace bug -----"
+          $stderr.puts "cannot convert class name #{klass} => #{klass_name}"
+          $stderr.puts e.full_message
+          $stderr.puts "------------------------"
+          raise
+        end
+        return ret_klass
+      end
+
+      # maybe this class is object's singleton class / special named class.
+      # I can't find efficient way, so cache the calculated result.
+      if @singleton_class_map_cache.key?(klass)
+        return @singleton_class_map_cache[klass]
+      end
+      begin
+        ret_klass = ObjectSpace.each_object(Module).find{|x| x.singleton_class == klass}
+        @singleton_class_map_cache[klass] = ret_klass
+      rescue => e
+        $stderr.puts "----- argtrace bug -----"
+        $stderr.puts "cannot convert class name #{klass} => #{klass_name}"
+        $stderr.puts e.full_message
+        $stderr.puts "------------------------"
+        raise
+      end
+      return ret_klass
+    end
+
+    # convert parameters to Parameter[]
+    def get_param_types(parameters, tp)
+      if tp.event == :c_call
+        # I cannot get parameter values of c_call ...
+        return []
+      else
+        return parameters.map{|param|
+          # param[0]=:req, param[1]=:x
+          p = Parameter.new
+          p.mode = param[0]
+          p.name = param[1]
+          if param[0] == :block
+            p.type = Signature.new
+          elsif param[1] == :* || param[1] == :&
+            # workaround for ActiveSupport gem.
+            # I don't know why this happen. just discard info about it.
+            type = TypeUnion.new
+            p.type = type
+          else
+            # TODO: this part is performance bottleneck caused by eval,
+            # but It's essential code
+            type = TypeUnion.new
+            begin
+              val = tp.binding.eval(param[1].to_s)
+            rescue => e
+              $stderr.puts "----- argtrace bug -----"
+              $stderr.puts parameters.inspect
+              $stderr.puts e.full_message
+              $stderr.puts "------------------------"
+              raise
+            end
+            type.add Type.new_with_value(val)
+            p.type = type
+          end
+          p
+        }
+      end
+    end
+
+    # pickup block parameter as proc if exists
+    def get_block_param_value(parameters, tp)
+      if tp.event == :c_call
+        # I cannot get parameter values of c_call ...
+        return nil
+      else
+        parameters.each do |param|
+          if param[0] == :block
+            if param[1] == :&
+              # workaround for ActiveSupport gem.
+              # I don't know why this happen. just discard info about it.
+              return nil
+            end
+            begin
+              val = tp.binding.eval(param[1].to_s)
+            rescue => e
+              $stderr.puts "----- argtrace bug -----"
+              $stderr.puts parameters.inspect
+              $stderr.puts e.full_message
+              $stderr.puts "------------------------"
+              raise
+            end
+            return val
+          end
+        end
+        return nil
+      end
+    end
+
+    # current called method object
+    def get_called_method(tp)
+      if tp.defined_class != tp.self.class
+        # I cannot identify all cases for this, so checks strictly.
+
+        if tp.defined_class.singleton_class?
+          # On class method call, "defined_class" becomes singleton(singular) class.
+        elsif tp.self.is_a?(tp.defined_class)
+          # On ancestor's method call, "defined_class" is different from self.class.
+        else
+          # This is unknown case.
+          raise "type inconsistent def:#{tp.defined_class} <=> self:#{tp.self.class} "
+        end
+      end
+      return tp.self.method(tp.method_id)
+    end
+
+    # true for the unhandleable events
+    def ignore_event?(tp)
+      if tp.defined_class.equal?(Class) and tp.method_id == :new
+        # On "Foo.new", I want "Foo" here,
+        # but "binding.receiver" equals to caller's "self" so I cannot get "Foo" from anywhere.
+        # Just ignore.
+        return true
+      end
+    
+      if tp.defined_class.equal?(BasicObject) and tp.method_id == :initialize
+        # On "Foo#initialize", I want "Foo" here,
+        # but if "Foo" doesn't  have explicit "initialize" method then no clue to get "Foo".
+        # Just ignore.
+        return true
+      end
+    
+      if tp.defined_class.equal?(Class) and tp.method_id == :inherited
+        # I can't understand this.
+        # Just ignore.
+        return true
+      end
+    
+      if tp.defined_class.equal?(Module) and tp.method_id == :method_added
+        # I can't understand this.
+        # Just ignore.
+        return true
+      end
+    
+      return false
+    end
+
+    # check filter from set_filter
+    def check_event_filter(tp)
+      if @prune_event_filter
+        return @prune_event_filter.call(tp)
+      else
+        return true
+      end
+    end
+
+    # set event filter
+    #   true = normal process
+    #   false = skip notify
+    #   :prune = skip notify and skip all nested events
+    def set_filter(&prune_event_filter)
+      @prune_event_filter = prune_event_filter
+    end
+
+    def set_exit(&exit_block)
+      @exit_block = exit_block
+    end
+
+    def set_notify(&notify_block)
+      @notify_block = notify_block
+    end
+
+    def call_exit
+      @exit_block.call if @exit_block
+    end
+
+    def enable
+      @tp_holder.enable
+    end
+
+    def disable
+      @tp_holder.disable
+    end
+
+    def stop_trace()
+      self.disable
+      Tracer.remove_running_trace(self)
+    end
+
+    # start TracePoint with callback block
+    def start_trace()
+      tp = TracePoint.new(:c_call, :c_return, :call, :return, :b_call) do |tp|
+        begin
+          tp.disable
+          # DEBUG:
+          # p [tp.event, tp.defined_class, tp.method_id]
+          self.trace(tp)
+        rescue => e
+          $stderr.puts "----- argtrace catch exception -----"
+          $stderr.puts e.full_message
+          $stderr.puts "------------------------------------"
+          @is_dead = true
+        ensure
+          tp.enable unless @is_dead
+        end
+      end
+      @tp_holder = tp
+
+      # hold reference and register at_exit
+      Tracer.add_running_trace(self)
+
+      tp.enable
+    end
+    
+    @@running_trace_first = true
+    @@running_trace = []
+    def self.add_running_trace(trace)
+      @@running_trace << trace
+      if @@running_trace_first
+        @@running_trace_first = false
+        at_exit do
+          @@running_trace.each do |trace|
+            trace.disable
+          end
+          @@running_trace.each do |trace|
+            trace.call_exit
+          end
+          @@running_trace.clear
+        end
+      end
+    end
+
+    def self.remove_running_trace(trace)
+      @@running_trace.delete(trace)
+    end
+
+  end
+
+end

data/lib/argtrace/typelib.rb

@@ -0,0 +1,230 @@
+require 'set'
+
+module Argtrace
+
+  # Store of signatures
+  class TypeLib
+    # class => { method_id => [normal_method_signature, singleton_method_signature] }
+    def lib
+      @lib
+    end
+
+    def initialize
+      @lib = Hash.new{|hklass, klass|
+        hklass[klass] = Hash.new{|hmethod, method_id|
+          hmethod[method_id] = [nil, nil]
+        }
+      }
+    end
+
+    def ready_signature(signature)
+      pair = @lib[signature.defined_class][signature.method_id]
+      index = signature.is_singleton_method ? 1 : 0
+      unless pair[index]
+        sig = Signature.new
+        sig.defined_class = signature.defined_class
+        sig.method_id = signature.method_id
+        sig.is_singleton_method = signature.is_singleton_method
+        sig.return_type = nil
+        pair[index] = sig
+      end
+      return pair[index]
+    end
+
+    def learn(signature)
+      ready_signature(signature).merge(signature.params, signature.return_type)
+    end
+
+    def to_rbs
+      # TODO: should I output class inheritance info ?
+      # TODO: private/public
+      # TODO: attr_reader/attr_writer/attr_accessor
+      mod_root = OutputModule.new
+
+      @lib.keys.sort_by{|x| x.to_s}.each do |klass|
+        klass_methods = @lib[klass]
+
+        # output instance method first, and then output singleton method.
+        [0, 1].each do |instance_or_singleton|
+          klass_methods.keys.sort.each do |method_id|
+            sig = klass_methods[method_id][instance_or_singleton]
+            next unless sig
+
+            mod_root.add_signature(sig)
+          end
+        end
+      end
+
+      mod_root.to_rbs
+    end
+  end
+
+  # helper to convert TypeLib into RBS. OutputMoudle acts like Module tree node.
+  class OutputModule
+    attr_accessor :actual_module, :name, :children, :signatures
+
+    def initialize
+      @children = {}
+      @signatures = []
+    end
+
+    def add_signature(signature)
+      # this is root node, so use Kernel as const resolve source.
+      @actual_module = Kernel
+
+      constname = class_const_name(signature.defined_class)
+      unless constname
+        # cannot handle this
+        return
+      end
+
+      add_signature_inner(constname, signature)
+    end
+
+    # split class name into consts (e.g. Argtrace::TypeLib to ["Argtrace", "TypeLib"])
+    def class_const_name(klass)
+      if /^[A-Za-z0-9_:]+$/ =~ klass.to_s
+        # this should be normal name
+        consts = klass.to_s.split("::")
+
+        # assertion
+        resolved_class = consts.inject(Kernel){|mod, const| mod.const_get(const)}
+        if klass != resolved_class
+          $stderr.puts "----- argtrace bug -----"
+          $stderr.puts "#{klass} => #{consts} => #{resolved_class}"
+          $stderr.puts "------------------------"
+          raise "Failed to resolve class by constant"
+        end
+
+        return consts
+      else
+        return nil
+      end
+    end
+
+    def add_signature_inner(name_consts, signature)
+      if name_consts.empty?
+        @signatures << signature
+      else
+        unless @children.key?(name_consts.first)
+          mod = OutputModule.new
+          mod.name = name_consts.first
+          mod.actual_module = @actual_module.const_get(name_consts.first)
+          @children[name_consts.first] = mod
+        end
+        current_resolving_name = name_consts.shift
+        @children[current_resolving_name].add_signature_inner(name_consts, signature)
+      end
+    end
+
+    def to_rbs
+      # this is root node
+      lines = []
+      @children.keys.sort.each do |child_name|
+        lines << @children[child_name].to_rbs_inner(0)
+        lines << ""
+      end
+      return lines.join("\n")
+    end
+
+    def to_rbs_inner(indent_level)
+      indent = "  " * indent_level
+      classmod_def = @actual_module.class == Class ? "class" : "module"
+
+      lines = []
+      lines << "#{indent}#{classmod_def} #{name}"
+      @children.keys.sort.each do |child_name|
+        lines << @children[child_name].to_rbs_inner(indent_level + 1)
+        lines << ""
+      end
+      @signatures.each do |sig|
+        lines << sig_to_rbs(indent_level + 1, sig)
+      end
+      lines << "#{indent}end"
+      return lines.join("\n")
+    end
+
+    def sig_to_rbs(indent_level, signature)
+      indent = "  " * indent_level
+      sig_name = signature.is_singleton_method ? "self.#{signature.method_id}" : signature.method_id
+      params = signature.params
+        .filter{|p| p.mode != :block}
+        .map{|p| param_to_rbs(p)}
+        .compact
+        .join(", ")
+      rettype = type_union_to_rbs(signature.return_type)
+      blocktype = blocktype_to_rbs(signature.params.find{|p| p.mode == :block})
+      return "#{indent}def #{sig_name} : (#{params})#{blocktype} -> #{rettype}"
+    end
+
+    def blocktype_to_rbs(blockparam)
+      unless blockparam
+        return ""
+      end
+      params = blockparam.type.params
+        .map{|p| type_union_to_rbs(p.type)}
+        .join(", ")
+      return " { (#{params}) -> untyped }"
+    end
+
+    def param_to_rbs(param)
+      case param.mode
+      when :req
+        return "#{type_union_to_rbs(param.type)} #{param.name}"
+      when :opt
+        return "?#{type_union_to_rbs(param.type)} #{param.name}"
+      when :keyreq
+        return "#{param.name}: #{type_union_to_rbs(param.type)}"
+      when :key
+        return "?#{param.name}: #{type_union_to_rbs(param.type)}"
+      when :block
+        return nil
+      end
+    end
+
+    def type_union_to_rbs(typeunion)
+      if typeunion.union.size == 0
+        return "untyped"
+      end
+      # TODO: ugly
+      if typeunion.union.size == 1 and NilClass == typeunion.union.first.data
+        # TODO: I can't distinguish nil and untyped.
+        return "untyped"
+      end
+      if typeunion.union.size == 2 and typeunion.union.any?{|x| NilClass == x.data}
+        # type is nil and sometype, so represent it as "sometype?"
+        sometype = typeunion.union.find{|x| NilClass != x.data}
+        return "#{type_to_rbs(sometype)}?"
+      end
+
+      ret = typeunion.union.map{|type| type_to_rbs(type)}.join("|")
+      return ret
+    end
+
+    def type_to_rbs(type)
+      if type.data.is_a?(Symbol)
+        return type.data.inspect
+      elsif true == type.data || false == type.data || BooleanClass == type.data
+        return "bool"
+      elsif nil == type.data || NilClass == type.data
+        return "nil"
+      elsif Array == type.data
+        if type.subdata
+          case type.subdata
+          when true, false, BooleanClass
+            elementtype = "bool"
+          else
+            elementtype = type.subdata.to_s
+          end
+          return "Array[#{elementtype}]"
+        else
+          return "Array"
+        end
+      else
+        return type.data.to_s
+      end
+    end
+
+  end
+end
+

data/lib/argtrace/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Argtrace
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: argtrace
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Riki Ishikawa
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-03-14 00:00:00.000000000 Z
+dependencies: []
+description: library to trace arguments of method calls or block calls with TracePoint
+  and do callback.
+email:
+- riki.ishikawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- argtrace.gemspec
+- bin/console
+- bin/setup
+- lib/argtrace.rb
+- lib/argtrace/autorun.rb
+- lib/argtrace/default.rb
+- lib/argtrace/signature.rb
+- lib/argtrace/tracer.rb
+- lib/argtrace/typelib.rb
+- lib/argtrace/version.rb
+homepage: https://github.com/jljse/argtrace/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jljse/argtrace/
+  source_code_uri: https://github.com/jljse/argtrace/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: trace arguments of method calls or block calls.
+test_files: []