orthoses 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ee37ddf25be5bbed113698301a2aeafb3b50e7af1da412b9a1fc6afad18d8c2
-  data.tar.gz: '075957101080441e02f4129303e766ecdfe1e7f30616177bc41a2cbf41f521f8'
+  metadata.gz: 0bde1745c71d6d30b7b45ce7f956a1c02f0d44353932c3743211aa1c05f58d39
+  data.tar.gz: bbe5b95a7665d39faab82b5f53e18cffd22962df1913f1c52698ea51c6045e2c
 SHA512:
-  metadata.gz: 98c1cff14563ecf14713890e56bddb053d6f128aacad7ff23b6f96cc8b2c338cbea511cc668ac18079ec921cb0183b145f6b26a3c04403a98e8aa0bf734942f7
-  data.tar.gz: 5dd573a63a6998e3a1fac1dd94f292dd80742185277124f6449ded149be662b74995815bad629157fc553cb8bef15bb31b123fdbcdccb1af3dff4d2645bc0da2
+  metadata.gz: 496d255f99751ac854e5b05ecac69b1e0dc7dbb5fca53bf99d6d622e2dbb154af643de7bf8de8190dca15ff1933fac35c17735da9285532a8a3246d7002836cd
+  data.tar.gz: 56c77cf9074eeb75547c1be3868e9843b0d5337400d2248592879f76fd6cc14f99660d8dbbf593c1d66bac1152e1dafbaa4820ea45a49f5f47945027ce45d53a

data/Gemfile

@@ -8,4 +8,8 @@ gemspec
 gem "rbs"
 gem "rake", "~> 13.0"
 gem "rgot", "~> 1.1"
-gem "steep"
+gem "activesupport"
+
+group :steep do
+  gem "steep", "1.4.0.dev.2"
+end

data/Gemfile.lock

@@ -1,43 +1,44 @@
 PATH
   remote: .
   specs:
-    orthoses (1.4.0)
-      rbs (~> 2.0)
+    orthoses (1.6.0)
+      rbs (~> 3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.4)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     ast (2.4.2)
-    concurrent-ruby (1.1.10)
-    csv (3.2.5)
+    concurrent-ruby (1.2.2)
+    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)
-    listen (3.7.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    listen (3.8.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    logger (1.5.1)
-    minitest (5.16.3)
+    logger (1.5.3)
+    minitest (5.18.0)
     parallel (1.22.1)
-    parser (3.1.2.1)
+    parser (3.2.1.1)
       ast (~> 2.4.1)
+    pathname (0.2.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)
-    rgot (1.1.0)
-    securerandom (0.2.0)
-    steep (1.2.1)
+    rbs (3.0.4)
+    rgot (1.3.0)
+    securerandom (0.2.2)
+    steep (1.4.0.dev.2)
       activesupport (>= 5.1)
       csv (>= 3.0.9)
       fileutils (>= 1.1.0)
@@ -47,27 +48,29 @@ GEM
       logger (>= 1.3.0)
       parallel (>= 1.0.0)
       parser (>= 3.1)
+      pathname (>= 0.2.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.6)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
-    tzinfo (2.0.5)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.3.0)
+    unicode-display_width (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
   orthoses!
   rake (~> 13.0)
   rbs
   rgot (~> 1.1)
-  steep
+  steep (= 1.4.0.dev.2)
 
 BUNDLED WITH
-   2.3.9
+   2.4.8

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/call_tracer/lazy.rb

@@ -2,6 +2,18 @@
 
 module Orthoses
   class CallTracer
+    # CallTracer::Lazy is possible to perform a trace
+    # equivalent to CallTracer before method is defined.
+    #     scope = CallTracerLazy.new
+    #     scope.trace("ActiveRecord::Base#scope") do
+    #       require 'active_record/all'
+    #       @loader.call
+    #     end
+    #     scope.captures.each do |capture|
+    #       capture.argument[:name]
+    #       capture.argument[:body]
+    #       capture.argument[:block]
+    #     end
     class Lazy
       include Capturable
 

data/lib/orthoses/content/duplication_checker.rb

@@ -11,7 +11,7 @@ module Orthoses
         return unless @decl.respond_to?(:members)
         uniq_map = {}
         @decl.members.each do |member|
-          if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overload
+          if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overloading?
             # avoid to duplicate and keep order
             uniq_map[Object.new] = member
           else

data/lib/orthoses/content/environment.rb

@@ -7,7 +7,8 @@ module Orthoses
             paths.each do |path|
               Orthoses.logger.debug("Load #{path}")
               buffer = RBS::Buffer.new(name: path.to_s, content: File.read(path.to_s, encoding: "UTF-8"))
-              RBS::Parser.parse_signature(buffer).each do |decl|
+              _, _, decls = RBS::Parser.parse_signature(buffer)
+              decls.each do |decl|
                 env << decl
               end
             end

data/lib/orthoses/content/header_builder.rb

@@ -3,7 +3,7 @@ module Orthoses
     class HeaderBuilder
       def initialize(env:)
         @env = env
-        @resolver = RBS::TypeNameResolver.from_env(env)
+        @resolver = RBS::Resolver::TypeNameResolver.new(env)
       end
 
       def build(entry:, name_hint: nil)
@@ -66,11 +66,10 @@ module Orthoses
         "interface #{name_and_params(resolved_name.relative!, entry.decl.type_params)}"
       end
 
+      include RBS::Environment::ContextUtil
+
       def build_context(entry:)
-        context = entry.outer.length.times.map do |i|
-          entry.outer[0, i + 1].map(&:name).inject(:+).to_namespace.absolute!
-        end
-        context.push(RBS::Namespace.root)
+        calculate_context(entry.outer + [entry.decl])
       end
 
       def name_and_params(name, params)

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)
@@ -105,7 +119,7 @@ module Orthoses
         name: "orthoses/content.rb",
         content: original_rbs
       )
-      parsed_decls = RBS::Parser.parse_signature(buffer)
+      _, _, parsed_decls = RBS::Parser.parse_signature(buffer)
       unless parsed_decls.length == 1
         raise "expect decls.length == 1, but got #{parsed_decls.length}"
       end

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,202 @@
+# 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,
+              overloading: false,
+              overloads: types.map { |type|
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  annotations: [],
+                  method_type: type
+                )
+              },
+              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!
@@ -49,28 +50,6 @@ module Orthoses
       RBS::Namespace.parse(name).to_type_name
     end
 
-    class << self
-      # Generated scripts are not always located in the root.
-      # By default, it follows the upper level directory from the current directory
-      # to find the rbs_collection.yaml file and set it to `rbs_collection_pathname`.
-      # It can be reconfigured if necessary.
-      attr_accessor :rbs_collection_pathname
-    end
-    # set default
-    self.rbs_collection_pathname = ->() {
-      begin
-        start = here = Dir.pwd
-        until ok = RBS::Collection::Config::PATH.exist?
-          Dir.chdir("..")
-          return nil if Dir.pwd == here
-          here = Dir.pwd
-        end
-        Pathname(here) + RBS::Collection::Config::PATH
-      ensure
-        Dir.chdir(start)
-      end
-    }.call
-
     def self.rbs_environment(library: nil, collection: true, cache: true)
       @env_cache ||= {}
       if cache && hit = @env_cache[[library, collection]]
@@ -79,9 +58,15 @@ module Orthoses
 
       loader = RBS::EnvironmentLoader.new
 
-      if collection && rbs_collection_pathname
-        config = RBS::Collection::Config.lockfile_of(rbs_collection_pathname) or raise
-        loader.add_collection(config)
+      if collection
+        config_path = RBS::Collection::Config.find_config_path || RBS::Collection::Config::PATH || raise("needs rbs_collection.yaml")
+        lock_path = RBS::Collection::Config.to_lockfile_path(config_path)
+        raise "needs rbs_collection.yaml file" unless lock_path.file?
+        lock = RBS::Collection::Config::Lockfile.from_lockfile(
+          lockfile_path: lock_path,
+          data: YAML.load_file(lock_path.to_s)
+        )
+        loader.add_collection(lock)
       end
 
       case library
@@ -101,7 +86,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 +100,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 +127,7 @@ module Orthoses
           if strict
             "[#{ary.join(', ')}]"
           else
-            "Array[#{ary.uniq.join(' | ')}]"
+            "Array[#{TypeList.new(ary).inject}]"
           end
         end
       when Hash
@@ -146,9 +137,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.6.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/orthoses.gemspec

@@ -32,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rbs", "~> 2.0"
+  spec.add_dependency "rbs", "~> 3.0"
 end

data/sig/orthoses/call_tracer/lazy.rbs

@@ -2,5 +2,6 @@
 
 class Orthoses::CallTracer::Lazy
   def initialize: () -> void
-  def trace: (untyped name) ?{ () -> untyped } -> untyped
+  def trace: (String name) ?{ () -> untyped } -> untyped
+  attr_reader captures: Array[untyped]
 end

data/sig/orthoses/call_tracer.rbs

@@ -2,6 +2,6 @@
 
 class Orthoses::CallTracer
   def initialize: () -> void
-  def trace: [T] (Method | UnboundMethod) ?{ () -> T } -> T
+  def trace: (Method | UnboundMethod) ?{ () -> untyped } -> untyped
   attr_accessor captures: Array[Capture]
 end

data/sig/orthoses/content/header_builder.rbs

@@ -10,4 +10,5 @@ class Orthoses::Content::HeaderBuilder
   private def build_context: (entry: untyped) -> untyped
   private def name_and_params: (untyped name, untyped params) -> ::String
   private def name_and_args: (untyped name, untyped args) -> (::String | nil)
+  include RBS::Environment::ContextUtil
 end

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/lazy_trace_point.rbs

@@ -3,7 +3,7 @@
 class Orthoses::LazyTracePoint < ::TracePoint
   def method_added: (untyped id) -> untyped
   def singleton_method_added: (untyped id) -> untyped
-  def initialize: (*untyped events) ?{ () -> untyped } -> void
+  def initialize: (*untyped events) { () -> untyped } -> void
   def enable: (?target: untyped?, ?target_line: untyped?, ?target_thread: untyped?) ?{ () -> untyped } -> untyped
   private def trace_instance_method: () ?{ () -> untyped } -> untyped
   private def trace_singleton_method: () ?{ () -> untyped } -> 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?
 
@@ -24,6 +24,4 @@ module Orthoses::Utils
   def self.new_store: () -> Orthoses::store
 
   UNBOUND_NAME_METHOD: UnboundMethod
-
-  attr_accessor self.rbs_collection_pathname: Pathname
 end

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.6.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.6.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-22 00:00:00.000000000 Z
+date: 2023-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 description: Build RBS by Rack base architecture
 email:
 - co000ri@gmail.com
@@ -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.8
 signing_key:
 specification_version: 4
 summary: Framework for Generate RBS