rbs-dynamic 0.1.0

data/lib/rbs/dynamic/tracer/called_method.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require_relative "../refine/trace_point.rb"
+require_relative "../refine/each_called_method.rb"
+
+module RBS module Dynamic module Tracer
+  class CalledMethod
+    using Refine::TracePoint
+    using Refine::TracePoint::ToRBSType
+    using Refine::BasicObjectWithKernel
+
+    using Module.new {
+      refine BasicObject do
+        def instance_variable_table
+          instance_variables.to_h { |name|
+            [name, instance_variable_get(name)]
+          }
+        end
+      end
+
+      refine Hash do
+        using Module.new {
+          refine Module do
+            def original_classname
+              if singleton_class?
+                self.superclass.name
+              else
+                self.name
+              end
+            end
+          end
+
+          refine Hash do
+            def to_arg_s
+              if self[:op] == :key
+                "#{self[:name]}: #{self[:value].inspect}"
+              else
+                "#{self[:name]} = #{self[:value].inspect}"
+              end
+            end
+          end
+        }
+
+        def method_sig
+          if self[:defined_class].singleton_class?
+            "#{self[:defined_class].original_classname}.#{seif[:method_id]}(#{self[:arguments].map(&:to_arg_s).join(", ")})"
+          elsif self[:defined_class] == BasicObject
+            "#{self[:method_id]}(#{self[:arguments].map(&:to_arg_s).join(", ")})"
+          else
+            "#{self[:defined_class].original_classname}##{self[:method_id]}(#{self[:arguments].map(&:to_arg_s).join(", ")})"
+          end
+        end
+
+        def difference(other)
+          other.map { |key, value| [key, [self[key], value]] if value != self[key] }.compact.to_h
+        end
+      end
+    }
+
+    attr_reader :call_stack
+    attr_reader :called_line_stack
+    attr_reader :trace_point
+
+    def initialize(
+      target_filepath_pattern: /.*/,
+      ignore_filepath_pattern: nil,
+      target_classname_pattern: /.*/,
+      ignore_classname_pattern: nil,
+      trace_c_api_method: false
+    )
+      @target_filepath_pattern = Regexp.new(target_filepath_pattern)
+      @ignore_filepath_pattern = ignore_filepath_pattern && Regexp.new(ignore_filepath_pattern)
+      @target_classname_pattern = Regexp.new(target_classname_pattern)
+      @ignore_classname_pattern = ignore_classname_pattern && Regexp.new(ignore_classname_pattern)
+      @trace_c_api_method = trace_c_api_method
+      clear
+    end
+
+    def clear
+      @call_stack = [{ called_methods: [], block: [] }]
+      @last_event = nil
+      @called_line_stack = [{}]
+      @ignore_rbs_dynamic_trace = false
+      @trace_point = TracePoint.new(*tarvet_event, &method(:trace_call_methods))
+      @trace_point.extend trace_point_ext
+    end
+
+    def called_methods
+      {
+        called_methods: call_stack.first[:called_methods]
+      }
+    end
+
+    def ignore_rbs_dynamic_trace(&block)
+      @ignore_rbs_dynamic_trace = true
+      block.call
+    ensure
+      @ignore_rbs_dynamic_trace = false
+    end
+
+    def enable(**opt, &block)
+      clear
+      trace_point.enable(**opt, &block)
+      ignore_rbs_dynamic_trace { called_methods }
+    end
+
+    def disable(**opt)
+      ignore_rbs_dynamic_trace { trace_point.disable(**opt) }
+    end
+
+    def trace(**opt, &block)
+      enable(**opt, &block)
+    end
+
+    using Refine::EachCalledMethod
+    include Enumerable
+    def each(&block)
+      called_methods.each_called_method(&block)
+    end
+
+    private
+
+    def trace_point_ext
+      self_ = self
+      Module.new {
+        define_method(:__called_methods__) {
+          self_.called_methods
+        }
+
+        define_method(:__ignore_rbs_dynamic_trace__) {
+          self_.ignore_rbs_dynamic_trace(&block)
+        }
+      }
+    end
+
+    def tarvet_event
+      if @trace_c_api_method
+        %i(line call return b_call b_return c_call c_return)
+      else
+        %i(line call return b_call b_return)
+      end
+    end
+
+    def target_event?(tp)
+      tarvet_event.include?(tp.event)
+    end
+
+    def target_filepath?(path)
+      @target_filepath_pattern =~ path
+    end
+
+    def ignore_filepath?(path)
+      !target_filepath?(path) || (@ignore_filepath_pattern && @ignore_filepath_pattern =~ path)
+    end
+
+    def target_class?(klass)
+      return true if !(Module === klass) || klass.singleton_class?
+      @target_classname_pattern =~ klass&.name
+    end
+
+    def ignore_class?(klass)
+      return false if !(Module === klass) || klass.singleton_class?
+      @ignore_classname_pattern && @ignore_classname_pattern =~ klass&.name
+    end
+
+    def ignore_trace_call_methods?(tp)
+      tp.method_id == :ignore_rbs_dynamic_trace \
+      || tp.method_id == :__ignore_rbs_dynamic_trace__ \
+      || @ignore_rbs_dynamic_trace \
+      || ignore_filepath?(tp.path) \
+      || (ignore_class?(tp.receiver_class) || ignore_class?(tp.receiver_defined_class)) \
+      || !(target_class?(tp.receiver_class) || target_class?(tp.receiver_defined_class))
+    end
+
+    def trace_call_methods(tp)
+      return unless target_event?(tp)
+      return if ignore_trace_call_methods?(tp)
+
+      @last_event = tp.event
+      case tp.event
+      when :line
+        called_line_stack.last[:called_lineno] = tp.lineno
+        called_line_stack.last[:called_path] = tp.path
+        called_line_stack.last[:called_method_id] = tp.method_id
+      when :call
+        called_line_stack << called_line_stack.last.dup
+        called_line = called_line_stack.last
+        called_method = tp.meta.merge(
+          called_lineno: called_line[:called_lineno],
+          called_path: called_line[:called_path],
+          called_method_id: called_line[:called_method_id],
+          called_methods: [],
+          block?: false,
+          block: [],
+          trace_point_event: tp.event
+        )
+
+        call_stack.last[:called_methods] << called_method
+        call_stack << called_method
+      when :return
+        call_stack.last[:return_value_class] = tp.return_value.class
+        call_stack.last[:return_value_rbs_type] = tp.return_value.to_rbs_type
+        call_stack.last[:instance_variables_class] = tp.instance_variables_class
+        call_stack.last[:instance_variables_rbs_type] = tp.instance_variables_rbs_type
+        call_stack.pop if 1 < call_stack.size
+        called_line_stack.pop if 1 < called_line_stack.size
+      when :b_call
+        called_line_stack << called_line_stack.last.dup
+        called_line = called_line_stack.last
+        called_method = tp.meta.merge(
+          called_lineno: called_line[:called_lineno],
+          called_path: called_line[:called_path],
+          called_method_id: called_line[:called_method_id],
+          called_methods: [],
+          block?: true,
+          block: [],
+          trace_point_event: tp.event
+        )
+
+        call_stack.last[:called_methods] << called_method
+        call_stack.last[:block] << called_method
+        call_stack << called_method
+      when :b_return
+        call_stack.last[:return_value_class] = tp.return_value.class
+        call_stack.last[:return_value_rbs_type] = tp.return_value.to_rbs_type
+        call_stack.last[:instance_variables_class] = tp.instance_variables_class
+        call_stack.last[:instance_variables_rbs_type] = tp.instance_variables_rbs_type
+        call_stack.pop if 1 < call_stack.size
+        called_line_stack.pop if 1 < called_line_stack.size
+      when :c_call
+        called_line_stack << called_line_stack.last.dup
+        called_line = called_line_stack.last
+        called_method = tp.meta.merge(
+          called_lineno: called_line[:called_lineno],
+          called_path: called_line[:called_path],
+          called_method_id: called_line[:called_method_id],
+          called_methods: [],
+          block?: false,
+          block: [],
+          trace_point_event: tp.event
+        )
+
+        call_stack.last[:called_methods] << called_method
+        call_stack.last[:block] << called_method
+        call_stack << called_method
+      when :c_return
+        call_stack.last[:return_value_class] = tp.return_value.class
+        call_stack.last[:return_value_rbs_type] = tp.return_value.to_rbs_type
+        call_stack.last[:instance_variables_class] = tp.instance_variables_class
+        call_stack.last[:instance_variables_rbs_type] = tp.instance_variables_rbs_type
+        call_stack.pop if 1 < call_stack.size
+        called_line_stack.pop if 1 < called_line_stack.size
+      end
+    end
+  end
+end end end

data/lib/rbs/dynamic/tracer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "./tracer/called_method.rb"
+
+module RBS module Dynamic
+  module Tracer
+    def self.trace(**opt, &block)
+      CalledMethod.new(**opt).enable(&block)[:called_methods].first[:called_methods]
+    end
+  end
+end end

data/lib/rbs/dynamic/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RBS
+  module Dynamic
+    VERSION = "0.1.0"
+  end
+end

data/lib/rbs/dynamic.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "./dynamic/version"
+require_relative "./dynamic/config.rb"
+require_relative "./dynamic/tracer.rb"
+require_relative "./dynamic/converter/trace_to_rbs.rb"
+
+module RBS
+  module Dynamic
+    def self.trace(**options, &block)
+      config = Config.new(options)
+      tmp_stdout= $stdout
+      $stdout = StringIO.new unless config.stdout?
+      called_methods = RBS::Dynamic::Tracer.trace(
+        target_filepath_pattern: config.target_filepath_pattern,
+        ignore_filepath_pattern: config.ignore_filepath_pattern,
+        # Fiter by Converter, not Tracer
+        # Because it is difficult to filter considering `receiver_class` and `receiver_defined_class
+        # target_classname_pattern: config.target_classname_pattern,
+        # ignore_classname_pattern: config.ignore_classname_pattern,
+        trace_c_api_method: config.trace_c_api_method?,
+        &block
+      )
+      Converter::TraceToRBS.new(called_methods).convert(
+        root_path: config.root_path,
+        except_build_members: config.except_build_members,
+        method_defined_calssses: config.method_defined_calssses,
+        include_method_location: config.show_method_location?,
+        use_literal_type: config.use_literal_type?,
+        with_literal_type: config.with_literal_type?,
+        use_interface_method_argument: config.use_interface_method_argument?,
+        target_classname_pattern: config.target_classname_pattern,
+        ignore_classname_pattern: config.ignore_classname_pattern
+      )
+    ensure
+      $stdout = tmp_stdout
+    end
+
+    def self.trace_to_rbs_text(**options, &block)
+      result = RBS::Dynamic.trace(**{ stdout: true }.merge(**options), &block)
+      decls = result.values
+      stdout = StringIO.new
+      writer = RBS::Writer.new(out: stdout)
+      writer.write(decls)
+      stdout.string
+    end
+  end
+end

data/rbs-dynamic.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/rbs/dynamic/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rbs-dynamic"
+  spec.version = RBS::Dynamic::VERSION
+  spec.authors = ["manga_osyo"]
+  spec.email = ["manga.osyo@gmail.com"]
+
+  spec.summary = "dynamic rbs generator"
+  spec.description = "dynamic rbs generator"
+  spec.homepage = "https://github.com/osyo-manga/gem-rbs-dynamic"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/osyo-manga/gem-rbs-dynamic"
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rbs"
+  spec.add_dependency "thor"
+
+  # 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, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sample/csv/sample.rb

@@ -0,0 +1,17 @@
+require "rbs/dynamic"
+require "csv"
+
+rbs = RBS::Dynamic.trace_to_rbs_text do
+  users =<<-EOS
+    id|first name|last name|age
+    1|taro|tanaka|20
+    2|jiro|suzuki|18
+    3|ami|sato|19
+    4|yumi|adachi|21
+  EOS
+
+  csv = CSV.new(users, headers: true, col_sep: "|")
+  p csv.class # => CSV
+  p csv.first # => #<CSV::Row "id":"1" "first name":"taro" "last name":"tanaka" "age":"20">
+end
+puts rbs

data/sample/fizzbuzz/sample.rb

@@ -0,0 +1,36 @@
+require "rbs/dynamic"
+
+class FizzBuzz
+  def initialize(value)
+    @value = value
+  end
+
+  def value; @value end
+
+  def apply
+      value % 15 == 0 ? "FizzBuzz"
+    : value %  3 == 0 ? "Fizz"
+    : value %  5 == 0 ? "Buzz"
+    : value
+  end
+end
+
+puts "Result"
+rbs = RBS::Dynamic.trace_to_rbs_text do
+  p (1..20).map { FizzBuzz.new(_1).apply }
+end
+puts rbs
+
+__END__
+output:
+Result
+[1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz", 16, 17, "Fizz", 19, "Buzz"]
+class FizzBuzz
+  private def initialize: (Integer value) -> Integer
+
+  def apply: () -> (Integer | String)
+
+  def value: () -> Integer
+
+  @value: Integer
+end

data/sample/fizzbuzz2/sample.rb

@@ -0,0 +1,66 @@
+require "rbs/dynamic"
+
+class Integer
+  def fizz?
+    self % 3 == 0
+  end
+
+  def buzz?
+    self % 5 == 0
+  end
+
+  def fizzbuzz?
+    fizz? && buzz?
+  end
+end
+
+class FizzBuzz
+  def to_fizzbuzz(value)
+      value.fizzbuzz? ? "FizzBuzz"
+    : value.fizz?     ? "Fizz"
+    : value.buzz?     ? "Buzz"
+    : value
+  end
+
+  def call(range, m = nil)
+    case [range, m]
+    in [Range, nil]
+      range.map { to_fizzbuzz(_1) }
+    in [Integer, nil]
+      call(0..range)
+    in [Integer, Integer]
+      call(range..m)
+    end
+  end
+end
+puts "Result"
+
+fizzbuzz = FizzBuzz.new
+
+# Generating RBS in block
+rbs = RBS::Dynamic.trace_to_rbs_text do
+  fizzbuzz.call(0..3)
+  fizzbuzz.call(30)
+  fizzbuzz.call(10, 20)
+end
+puts rbs
+__END__
+Result
+class Numeric
+end
+
+class FizzBuzz
+  def call: (Range[Integer] range, ?NilClass m) ?{ (?Integer _1) -> (String | Integer) } -> Array[String | Integer]
+    | (Integer range, ?NilClass m) -> Array[String | Integer]
+    | (Integer range, ?Integer m) -> Array[String | Integer]
+
+    def to_fizzbuzz: (Integer value) -> (String | Integer)
+end
+
+class Integer < Numeric
+  def fizzbuzz?: () -> bool
+
+  def fizz?: () -> bool
+
+  def buzz?: () -> bool
+end

data/sig/rbs/dynamic.rbs

@@ -0,0 +1,6 @@
+module Rbs
+  module Dynamic
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: rbs-dynamic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- manga_osyo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: dynamic rbs generator
+email:
+- manga.osyo@gmail.com
+executables:
+- rbs-dynamic
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- exe/rbs-dynamic
+- lib/bs/dynamic/trace.rb
+- lib/rbs/dynamic.rb
+- lib/rbs/dynamic/builder.rb
+- lib/rbs/dynamic/builder/methods.rb
+- lib/rbs/dynamic/builder/types.rb
+- lib/rbs/dynamic/cli.rb
+- lib/rbs/dynamic/config.rb
+- lib/rbs/dynamic/converter/called_method_to_sigunature.rb
+- lib/rbs/dynamic/converter/called_method_to_with_interface.rb
+- lib/rbs/dynamic/converter/trace_to_rbs.rb
+- lib/rbs/dynamic/refine/basic_object_with_kernel.rb
+- lib/rbs/dynamic/refine/each_called_method.rb
+- lib/rbs/dynamic/refine/signature_merger.rb
+- lib/rbs/dynamic/refine/trace_point.rb
+- lib/rbs/dynamic/trace.rb
+- lib/rbs/dynamic/tracer.rb
+- lib/rbs/dynamic/tracer/called_method.rb
+- lib/rbs/dynamic/version.rb
+- rbs-dynamic.gemspec
+- sample/csv/sample.rb
+- sample/fizzbuzz/sample.rb
+- sample/fizzbuzz2/sample.rb
+- sig/rbs/dynamic.rbs
+homepage: https://github.com/osyo-manga/gem-rbs-dynamic
+licenses: []
+metadata:
+  homepage_uri: https://github.com/osyo-manga/gem-rbs-dynamic
+  source_code_uri: https://github.com/osyo-manga/gem-rbs-dynamic
+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.3.7
+signing_key: 
+specification_version: 4
+summary: dynamic rbs generator
+test_files: []