orthoses 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ee37ddf25be5bbed113698301a2aeafb3b50e7af1da412b9a1fc6afad18d8c2
-  data.tar.gz: '075957101080441e02f4129303e766ecdfe1e7f30616177bc41a2cbf41f521f8'
+  metadata.gz: 843da9ba9bba3cf5c84ec56041836cb9469ad5faffd188f8edc13a3920ca499e
+  data.tar.gz: 791b0d87a885b327a41fff090f9dadce9b377712e9d7d51bd52fbaa997c98242
 SHA512:
-  metadata.gz: 98c1cff14563ecf14713890e56bddb053d6f128aacad7ff23b6f96cc8b2c338cbea511cc668ac18079ec921cb0183b145f6b26a3c04403a98e8aa0bf734942f7
-  data.tar.gz: 5dd573a63a6998e3a1fac1dd94f292dd80742185277124f6449ded149be662b74995815bad629157fc553cb8bef15bb31b123fdbcdccb1af3dff4d2645bc0da2
+  metadata.gz: 81438b5d94ce56d7164cdc781eaaa2c526cbba21cab147fc91d4e1b0c9b7992e31259d9bda2f5e2441a3dc59e3f7ec940c910e1cf63bbec6ef84ca4b046af0ee
+  data.tar.gz: ec0049000f94a194747974233adaa1c51a7759c0d78fb84a11e543877ee15d01f212b59ed63c5cadbd221701de4bfa9c84c0f6fcc5feffdab0f954b1fd63e2d0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    orthoses (1.4.0)
+    orthoses (1.5.0)
       rbs (~> 2.0)
 
 GEM
@@ -14,30 +14,30 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     concurrent-ruby (1.1.10)
-    csv (3.2.5)
+    csv (3.2.6)
     ffi (1.15.5)
-    fileutils (1.6.0)
+    fileutils (1.7.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    json (2.6.2)
-    language_server-protocol (3.17.0.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.2)
     listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    logger (1.5.1)
+    logger (1.5.2)
     minitest (5.16.3)
     parallel (1.22.1)
-    parser (3.1.2.1)
+    parser (3.1.3.0)
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.7.0)
+    rbs (2.8.1)
     rgot (1.1.0)
-    securerandom (0.2.0)
-    steep (1.2.1)
+    securerandom (0.2.1)
+    steep (1.3.0)
       activesupport (>= 5.1)
       csv (>= 3.0.9)
       fileutils (>= 1.1.0)
@@ -48,11 +48,11 @@ GEM
       parallel (>= 1.0.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 2.7.0)
+      rbs (>= 2.8.0)
       securerandom (>= 0.1)
       strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
-    strscan (3.0.4)
+    strscan (3.0.5)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.5)

data/README.md

@@ -169,6 +169,14 @@ Run `rbs prototype runtime` command process with `patterns` option string.
 
 Force load const defined by `autoload`.
 
+### Orthoses::Sort
+
+Sort signatures by class/module.
+
+## Orthoses::Trace
+
+Trace the argument and return value objects when the method is actually called and determine the type.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/examples/rack-test/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem "rack"
+gem "rake"
+gem "cgi"
+gem "minitest"
+gem "minitest-global_expectations"
+gem "orthoses", path: "../../"

data/examples/rack-test/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: ../..
+  specs:
+    orthoses (1.4.0)
+      rbs (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    cgi (0.3.6)
+    minitest (5.16.3)
+    minitest-global_expectations (1.0.1)
+      minitest (> 5)
+    rack (3.0.2)
+    rake (13.0.6)
+    rbs (2.8.1)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  cgi
+  minitest
+  minitest-global_expectations
+  orthoses!
+  rack
+  rake
+
+BUNDLED WITH
+   2.3.16

data/examples/rack-test/Rakefile

@@ -0,0 +1,7 @@
+file :src do
+  sh "git clone --depth 1 https://github.com/rack/rack-test.git src"
+end
+
+task :generate => :src do
+  load "generate.rb"
+end

data/examples/rack-test/generate.rb

@@ -0,0 +1,31 @@
+require 'pathname'
+require 'orthoses'
+require 'fileutils'
+
+include FileUtils
+
+out = Pathname('out')
+out.rmtree rescue nil
+Orthoses.logger.level = :warn
+Orthoses::Builder.new do
+  use Orthoses::CreateFileByName,
+    base_dir: out.to_s
+  # use Orthoses::Sort
+  use Orthoses::Filter do |name, content|
+    name.start_with?("Rack::Test")
+  end
+  use Orthoses::Trace,
+    patterns: ['Rack::Test*']
+  run ->(){
+    cd "src" do
+      load "spec/all.rb"
+      Minitest.run
+      # avoid to run on at_exit
+      module ::Minitest
+        def self.run args = []
+          0
+        end
+      end
+    end
+  }
+end.call

data/lib/orthoses/call_tracer/capturable.rb

@@ -25,13 +25,13 @@ module Orthoses
           else
             hash[name] = tp.binding.local_variable_get(name).then do |var|
               case var
-              when Module, Thread::Backtrace::Location
+              when Module, Thread::Backtrace::Location, IO, Encoding
                 var
               else
                 var.dup
               end
             rescue => err
-              warn("#dup fail (#{err.class}) #{err.message}")
+              warn("#{var.class}#dup failed with #{err.class}:#{err.message}")
               var
             end
           end

data/lib/orthoses/content.rb

@@ -60,12 +60,17 @@ module Orthoses
     end
 
     def uniq!
-      out = ArrayIO.new
-      writer = RBS::Writer.new(out: out)
-      to_decl.members.each do |member|
-        writer.write_member(member)
-      end
-      @body.replace(out.to_a)
+      lines = decl_to_lines(to_decl)
+      @body.replace(lines)
+    end
+
+    def sort!
+      require 'rbs/sorter'
+      sorter = ::RBS::Sorter.new(nil, stdout: nil)
+      decl = to_decl
+      sorter.sort_decl!(decl)
+      lines = decl_to_lines(decl)
+      @body.replace(lines)
     end
 
     def original_rbs
@@ -93,6 +98,15 @@ module Orthoses
       end
     end
 
+    def decl_to_lines(decl)
+      out = ArrayIO.new
+      writer = RBS::Writer.new(out: out)
+      decl.members.each do |member|
+        writer.write_member(member)
+      end
+      out.to_a
+    end
+
     def uniqed_body_string
       out = StringIO.new
       writer = RBS::Writer.new(out: out)

data/lib/orthoses/sort.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Orthoses
+  # use Orthoses::Sort
+  class Sort
+    def initialize(loader)
+      @loader = loader
+    end
+
+    def call
+      @loader.call.tap do |store|
+        store.each do |name, content|
+          content.sort!
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/trace/attribute.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class Trace
+    class Attribute
+      include Targetable
+
+      def initialize(loader, patterns:)
+        @loader = loader
+        @patterns = patterns
+
+        @captured_dict = Hash.new { |h, k| h[k] = Hash.new { |hh, kk| hh[kk] = [] } }
+      end
+
+      def call
+        ::Module.prepend(Orthoses::Attribute::Hook)
+        store = nil
+        build_trace_hook.enable(target: Orthoses::Attribute::Hook.instance_method(:attr)) do
+          build_trace_hook.enable(target: Orthoses::Attribute::Hook.instance_method(:attr_accessor)) do
+            build_trace_hook.enable(target: Orthoses::Attribute::Hook.instance_method(:attr_reader)) do
+              build_trace_hook.enable(target: Orthoses::Attribute::Hook.instance_method(:attr_writer)) do
+                store = @loader.call
+              end
+            end
+          end
+        end
+
+        @captured_dict.each do |mod_name, captures|
+          captures.each do |(kind, prefix, name), types|
+            injected = Utils::TypeList.new(types).inject
+            store[mod_name] << "#{kind} #{prefix}#{name}: #{injected}"
+          end
+        end
+
+        store
+      end
+
+      private
+
+      def build_trace_hook
+        TracePoint.new(:call) do |tp1|
+          mod_name = Orthoses::Utils.module_name(tp1.self)
+          if m = tp1.self.to_s.match(/#<Class:([\w:]+)>/)
+            mod_name = m[1]
+          end
+          next unless mod_name
+          next unless target?(mod_name)
+          is_singleton = tp1.self.singleton_class?
+          prefix = is_singleton ? "self." : ""
+          kind = tp1.method_id
+
+          tp1.binding.local_variable_get(:names).each do |name|
+            attr_module = Module.new{
+              if [:attr_accessor, :attr_reader, :attr].include?(kind)
+                define_method(name) do
+                  super()
+                end
+              end
+              if [:attr_accessor, :attr_writer, :attr].include?(kind)
+                define_method("#{name}=") do |object|
+                  super(object)
+                end
+              end
+            }
+
+            tp1.self.prepend attr_module
+
+            if [:attr_accessor, :attr_reader, :attr].include?(kind)
+              TracePoint.new(:return) do |tp2|
+                type = Utils.object_to_rbs(tp2.return_value)
+                @captured_dict[mod_name][[kind, prefix, name]] << type
+              end.enable(target: attr_module.instance_method(name))
+            end
+            if [:attr_accessor, :attr_writer, :attr].include?(kind)
+              TracePoint.new(:call) do |tp2|
+                type = Utils.object_to_rbs(tp2.binding.local_variable_get(:object))
+                @captured_dict[mod_name][[kind, prefix, name]] << type
+              end.enable(target: attr_module.instance_method("#{name}="))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/trace/method.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class Trace
+    class Method
+      # internal
+      Info = Struct.new(:key, :op_name_types, :raised, keyword_init: true)
+      include Targetable
+
+      def initialize(loader, patterns:)
+        @loader = loader
+        @patterns = patterns
+
+        @stack = []
+        @args_return_map = Hash.new { |h, k| h[k] = [] }
+        @alias_map = {}
+      end
+
+      def call
+        build_trace_point.enable do
+          @loader.call
+        end.tap do |store|
+          build_members.each do |(mod_name, member)|
+            out = StringIO.new
+            writer = ::RBS::Writer.new(out: out)
+            writer.write_member(member)
+            store[mod_name] << out.string
+          end
+        end
+      end
+
+      private
+
+      def build_trace_point
+        TracePoint.new(:call, :return, :raise) do |tp|
+          case tp.event
+          when :call
+            if tp.defined_class.singleton_class?
+              # e.g. `Minitest::Spec::DSL#to_s`` may return `nil` with `#to_s`
+              m = tp.defined_class.to_s&.match(/#<Class:([\w:]+)>/) or next
+              mod_name = m[1] or next
+              kind = :singleton
+            else
+              mod_name = Utils.module_name(tp.defined_class) or next
+              kind = :instance
+            end
+
+            next unless target?(mod_name)
+
+            visibility = tp.self.private_methods.include?(tp.method_id) ? :private : nil
+            key = [mod_name, kind, visibility, tp.method_id]
+            op_name_types = tp.parameters.map do |op, name|
+              case name
+              when nil, :*, :**, :&
+                [op, name, 'untyped']
+              else
+                type = Utils.object_to_rbs(tp.binding.local_variable_get(name))
+                [op, name, type]
+              end
+            end
+
+            @alias_map[[mod_name, kind, tp.method_id]] = tp.callee_id if tp.method_id != tp.callee_id
+            @stack.push(Info.new(key: key, op_name_types: op_name_types, raised: false))
+          when :raise
+            @stack.last&.raised = true
+          when :return
+            info = @stack.pop
+            if info && !info.raised
+              @args_return_map[info.key] << [info.op_name_types, Utils.object_to_rbs(tp.return_value)]
+            end
+          end
+        end
+      end
+
+      def build_members
+        build_method_definitions.concat(build_aliases)
+      end
+
+      def build_method_definitions
+        untyped = ::RBS::Types::Bases::Any.new(location: nil)
+
+        @args_return_map.map do |(mod_name, kind, visibility, method_id), type_samples|
+          type_samples.uniq!
+          method_types = type_samples.map do |(op_name_types, return_type)|
+            required_positionals = []
+            optional_positionals = []
+            rest = nil
+            trailing_positionals = []
+            required_keywords = {}
+            optional_keywords = {}
+            rest_keywords = nil
+
+            requireds = required_positionals
+
+            block = nil
+
+            op_name_types.each do |op, name, string_type|
+              type = ::RBS::Parser.parse_type(string_type)
+
+              case op
+              when :req
+                requireds << ::RBS::Types::Function::Param.new(name: name, type: type)
+              when :opt
+                requireds = trailing_positionals
+                optional_positionals << ::RBS::Types::Function::Param.new(name: name, type: type)
+              when :rest
+                requireds = trailing_positionals
+                name = nil if name == :* # For `def f(...) end` syntax
+                rest = ::RBS::Types::Function::Param.new(name: name, type: type)
+              when :keyreq
+                required_keywords[name] = ::RBS::Types::Function::Param.new(name: nil, type: type)
+              when :key
+                optional_keywords[name] = ::RBS::Types::Function::Param.new(name: nil, type: type)
+              when :keyrest
+                rest_keywords = ::RBS::Types::Function::Param.new(name: nil, type: type)
+              when :block
+                block = ::RBS::Types::Block.new(
+                  type: ::RBS::Types::Function.empty(untyped).update(rest_positionals: ::RBS::Types::Function::Param.new(name: nil, type: untyped)),
+                  required: false,
+                  self_type: nil
+                )
+              end
+            end
+
+            return_type = if method_id == :initialize
+              ::RBS::Types::Bases::Void.new(location: nil)
+            else
+              ::RBS::Parser.parse_type(return_type)
+            end
+
+            ::RBS::MethodType.new(
+              location: nil,
+              type_params: [],
+              type: ::RBS::Types::Function.new(
+                required_positionals: required_positionals,
+                optional_positionals: optional_positionals,
+                rest_positionals: rest,
+                trailing_positionals: trailing_positionals,
+                required_keywords: required_keywords,
+                optional_keywords: optional_keywords,
+                rest_keywords: rest_keywords,
+                return_type: return_type,
+              ),
+              block: block
+            )
+          end
+
+          # from:
+          #   def foo: () -> true
+          #          | () -> false
+          #          | (Integer) -> Integer
+          # to:
+          #   def foo: () -> bool
+          #          | (Integer) -> Integer
+          functions_without_return_type_map = method_types.group_by do |method_type|
+            method_type.type.with_return_type(untyped)
+          end
+          types = functions_without_return_type_map.map do |func, method_types_by_arg|
+            injected = Utils::TypeList.new(method_types_by_arg.map(&:type).map(&:return_type)).inject
+            method_type = method_types_by_arg.first
+            method_type.update(type: method_type.type.with_return_type(injected))
+          end
+
+          [
+            mod_name,
+            RBS::AST::Members::MethodDefinition.new(
+              annotations: [],
+              comment: nil,
+              kind: kind,
+              location: nil,
+              name: method_id,
+              overload: false,
+              types: types,
+              visibility: visibility
+            )
+          ]
+        end
+      end
+
+      def build_aliases
+        @alias_map.map do |(mod_name, kind, method_id), callee_id|
+          [
+            mod_name,
+            RBS::AST::Members::Alias.new(
+              new_name: callee_id,
+              old_name: method_id,
+              kind: kind,
+              annotations: [],
+              location: nil,
+              comment: nil,
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/trace/targetable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Orthoses
+  class Trace
+    module Targetable
+      def target?(name)
+        @patterns.any? do |pattern|
+          if pattern.end_with?("*")
+            (name || "").start_with?(pattern.chop)
+          else
+            name == pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/trace.rb

@@ -0,0 +1,21 @@
+module Orthoses
+  # Collect argument and return types during code running
+  #     use Orthoses::Trace,
+  #         patterns: ['Foo::Bar*']
+  class Trace
+    autoload :Attribute, 'orthoses/trace/attribute'
+    autoload :Method, 'orthoses/trace/method'
+    autoload :Targetable, 'orthoses/trace/targetable'
+
+    def initialize(loader, patterns:)
+      @loader = loader
+      @patterns = patterns
+    end
+
+    def call
+      @loader = Trace::Attribute.new(@loader, patterns: @patterns)
+      @loader = Trace::Method.new(@loader, patterns: @patterns)
+      @loader.call
+    end
+  end
+end

data/lib/orthoses/utils/type_list.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module Utils
+    # internal
+    class TypeList
+      UNTYPED = ::RBS::Types::Bases::Any.new(location: nil)
+      NIL_TYPE = ::RBS::Types::Bases::Nil.new(location: nil)
+      TRUE_TYPE = ::RBS::Types::Literal.new(literal: true, location: nil)
+      FALSE_TYPE = ::RBS::Types::Literal.new(literal: false, location: nil)
+
+      def initialize(types)
+        @types = types.map do |type|
+          case type
+          when String
+            ::RBS::Parser.parse_type(type)
+          else
+            type
+          end
+        end
+      end
+
+      def inject
+        uniqed = @types.uniq
+
+        return UNTYPED if uniqed.find { |t| t == UNTYPED }
+
+        has_true = uniqed.delete(TRUE_TYPE)
+        has_false = uniqed.delete(FALSE_TYPE)
+        if has_true || has_false
+          uniqed << ::RBS::Types::Bases::Bool.new(location: nil)
+        end
+
+        return UNTYPED if uniqed.empty?
+        return uniqed.first if uniqed.length == 1
+
+        args_or_other = uniqed.group_by do |type|
+          type.respond_to?(:args) && !type.args.empty?
+        end
+        if args_or_other[true]
+          # { Array => [Array[Intger], Array[String]], Hash => [Hash[untyped, untyped]], ... }
+          type_by_name = args_or_other[true].group_by do |type|
+            type.name
+          end
+          type_by_name.each do |name, types|
+            if with_untyped_type = types.find { |type| type.args.include?(UNTYPED) }
+              types.replace([with_untyped_type])
+            end
+          end
+          args_injected = type_by_name.values.flatten
+          args_injected.concat(args_or_other[false]) if args_or_other[false]
+          uniqed = args_injected
+        end
+
+        after_optional = uniqed.delete(NIL_TYPE)
+        injected = uniqed.inject do |r, type|
+          case r
+          when ::RBS::Types::Union
+            r.tap { r.types << type }
+          else
+            ::RBS::Types::Union.new(types: [r, type], location: nil)
+          end
+        end
+
+        if after_optional
+          return ::RBS::Types::Optional.new(type: injected, location: nil)
+        end
+
+        injected
+      end
+    end
+  end
+end

data/lib/orthoses/utils.rb

@@ -2,6 +2,7 @@
 
 module Orthoses
   module Utils
+    autoload :TypeList, "orthoses/utils/type_list"
     autoload :Underscore, "orthoses/utils/underscore"
 
     def self.unautoload!
@@ -101,7 +102,7 @@ module Orthoses
       end
     end
 
-    def self.object_to_rbs(object, strict:)
+    def self.object_to_rbs(object, strict: false)
       case object
       when Class, Module
         if name = module_name(object)
@@ -115,8 +116,14 @@ module Orthoses
         else
           module_name(object.class) || 'untyped'
         end
-      when true, false, nil
-        object.inspect
+      when true, false
+        if strict
+          object.inspect
+        else
+          "bool"
+        end
+      when nil
+        "nil"
       when Set
         if object.empty?
           "Set[untyped]"
@@ -136,7 +143,7 @@ module Orthoses
           if strict
             "[#{ary.join(', ')}]"
           else
-            "Array[#{ary.uniq.join(' | ')}]"
+            "Array[#{TypeList.new(ary).inject}]"
           end
         end
       when Hash
@@ -146,9 +153,9 @@ module Orthoses
           if strict && object.keys.all? { |key| key.is_a?(Symbol) && /\A\w+\z/.match?(key) }
             "{ #{object.map { |k, v| "#{k}: #{object_to_rbs(v, strict: strict)}" }.join(', ')} }"
           else
-            keys = object.keys.map { |k| object_to_rbs(k, strict: strict) }.uniq
-            values = object.values.map { |v| object_to_rbs(v, strict: strict) }.uniq
-            "Hash[#{keys.join(' | ')}, #{values.join(' | ')}]"
+            keys = object.keys.map { |k| object_to_rbs(k, strict: strict) }
+            values = object.values.map { |v| object_to_rbs(v, strict: strict) }
+            "Hash[#{TypeList.new(keys).inject}, #{TypeList.new(values).inject}]"
           end
         end
       when Range

data/lib/orthoses/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Orthoses
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/lib/orthoses.rb

@@ -3,6 +3,8 @@
 require 'rbs'
 require 'pathname'
 
+require 'orthoses/utils'
+
 module Orthoses
   autoload :Attribute, 'orthoses/attribute'
   autoload :Builder, 'orthoses/builder'
@@ -21,10 +23,11 @@ module Orthoses
   autoload :PP, 'orthoses/pp'
   autoload :RBSPrototypeRB, 'orthoses/rbs_prototype_rb'
   autoload :RBSPrototypeRuntime, 'orthoses/rbs_prototype_runtime'
+  autoload :Sort, 'orthoses/sort'
   autoload :Store, 'orthoses/store'
   autoload :Tap, 'orthoses/tap'
+  autoload :Trace, 'orthoses/trace'
   autoload :Autoload, 'orthoses/autoload'
-  autoload :Utils, 'orthoses/utils'
   autoload :VERSION, 'orthoses/version'
   autoload :Walk, 'orthoses/walk'
   autoload :Writer, 'orthoses/writer'

data/sig/orthoses/content.rbs

@@ -10,7 +10,9 @@ class Orthoses::Content
   def to_rbs: () -> String
   def to_decl: () -> untyped
   def uniq!: () -> untyped
+  def sort!: () -> untyped
   def original_rbs: () -> untyped
+  private def decl_to_lines: (untyped decl) -> untyped
   private def uniqed_body_string: () -> String
   private def uniqed_body_decl: () -> RBS::AST::Declarations::t
   private def auto_header: () -> (nil | untyped)

data/sig/orthoses/sort.rbs

@@ -0,0 +1,6 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Sort
+  def initialize: (untyped loader) -> void
+  def call: () -> untyped
+end

data/sig/orthoses/trace/attribute.rbs

@@ -0,0 +1,8 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Trace::Attribute
+  def initialize: (untyped loader, patterns: untyped) -> void
+  def call: () -> untyped
+  private def build_trace_hook: () -> untyped
+  include Orthoses::Trace::Targetable
+end

data/sig/orthoses/trace/method/info.rbs

@@ -0,0 +1,4 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Trace::Method::Info < ::Struct[untyped]
+end

data/sig/orthoses/trace/method.rbs

@@ -0,0 +1,11 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Trace::Method
+  def initialize: (untyped loader, patterns: untyped) -> void
+  def call: () -> untyped
+  private def build_trace_point: () -> untyped
+  private def build_members: () -> untyped
+  private def build_method_definitions: () -> untyped
+  private def build_aliases: () -> untyped
+  include Orthoses::Trace::Targetable
+end

data/sig/orthoses/trace/targetable.rbs

@@ -0,0 +1,5 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+module Orthoses::Trace::Targetable
+  def target?: (untyped name) -> untyped
+end

data/sig/orthoses/trace.rbs

@@ -0,0 +1,6 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Trace
+  def initialize: (untyped loader, patterns: untyped) -> void
+  def call: () -> untyped
+end

data/sig/orthoses/utils/type_list.rbs

@@ -0,0 +1,10 @@
+# THIS IS GENERATED CODE from `$ rake generate_self_sig`
+
+class Orthoses::Utils::TypeList
+  def initialize: (untyped types) -> void
+  def inject: () -> untyped
+  FALSE_TYPE: RBS::Types::Literal
+  NIL_TYPE: RBS::Types::Bases::Nil
+  TRUE_TYPE: RBS::Types::Literal
+  UNTYPED: RBS::Types::Bases::Any
+end

data/sig/orthoses/utils.rbs

@@ -13,7 +13,7 @@ module Orthoses::Utils
 
   def self.rbs_environment: (?library: String | Array[String] | nil, ?collection: boolish, ?cache: boolish) -> RBS::Environment
 
-  def self.object_to_rbs: (untyped object, strict: bool) -> String
+  def self.object_to_rbs: (untyped object, ?strict: bool) -> String
 
   def self.module_name: (Module mod) -> String?
 

data/sig/orthoses.rbs

@@ -1,7 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
 module Orthoses
-  VERSION: "1.4.0"
+  VERSION: "1.5.0"
 
   attr_accessor self.logger: ::Logger
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orthoses
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-22 00:00:00.000000000 Z
+date: 2023-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -37,6 +37,10 @@ files:
 - LICENSE.txt
 - README.md
 - examples/minitest/Rakefile
+- examples/rack-test/Gemfile
+- examples/rack-test/Gemfile.lock
+- examples/rack-test/Rakefile
+- examples/rack-test/generate.rb
 - examples/simple_middleware.rb
 - examples/simple_middleware.rbs
 - lib/orthoses.rb
@@ -66,9 +70,15 @@ files:
 - lib/orthoses/pp.rb
 - lib/orthoses/rbs_prototype_rb.rb
 - lib/orthoses/rbs_prototype_runtime.rb
+- lib/orthoses/sort.rb
 - lib/orthoses/store.rb
 - lib/orthoses/tap.rb
+- lib/orthoses/trace.rb
+- lib/orthoses/trace/attribute.rb
+- lib/orthoses/trace/method.rb
+- lib/orthoses/trace/targetable.rb
 - lib/orthoses/utils.rb
+- lib/orthoses/utils/type_list.rb
 - lib/orthoses/utils/underscore.rb
 - lib/orthoses/version.rb
 - lib/orthoses/walk.rb
@@ -112,9 +122,16 @@ files:
 - sig/orthoses/pp.rbs
 - sig/orthoses/rbs_prototype_rb.rbs
 - sig/orthoses/rbs_prototype_runtime.rbs
+- sig/orthoses/sort.rbs
 - sig/orthoses/store.rbs
 - sig/orthoses/tap.rbs
+- sig/orthoses/trace.rbs
+- sig/orthoses/trace/attribute.rbs
+- sig/orthoses/trace/method.rbs
+- sig/orthoses/trace/method/info.rbs
+- sig/orthoses/trace/targetable.rbs
 - sig/orthoses/utils.rbs
+- sig/orthoses/utils/type_list.rbs
 - sig/orthoses/utils/underscore.rbs
 - sig/orthoses/walk.rbs
 - sig/orthoses/writer.rbs
@@ -139,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.16
+rubygems_version: 3.4.3
 signing_key:
 specification_version: 4
 summary: Framework for Generate RBS