orthoses 1.5.0 → 1.7.0

data/examples/rack-test/out/rack/test/utils.rbs

@@ -0,0 +1,112 @@
+module Rack::Test::Utils
+  def build_nested_query: (Hash[Symbol, Hash[Symbol, Array[Integer]]] value, ?nil prefix) -> String
+                        | (Hash[Symbol, Array[Integer]] value, ?String prefix) -> String
+                        | (Array[Integer] value, ?String prefix) -> String
+                        | (Integer value, ?String prefix) -> String
+                        | (Hash[Symbol, nil] value, ?nil prefix) -> String
+                        | (nil value, ?String prefix) -> String
+                        | (Hash[Symbol, Integer] value, ?nil prefix) -> String
+                        | (Hash[String, Array[Integer]] value, ?nil prefix) -> String
+                        | (nil value, ?nil prefix) -> String
+                        | (Hash[Symbol, Array[Integer]] value, ?nil prefix) -> String
+                        | (Hash[Symbol, Hash[Symbol, Integer]] value, ?nil prefix) -> String
+                        | (Hash[Symbol, Integer] value, ?String prefix) -> String
+                        | (Hash[Symbol, Array[untyped]] value, ?nil prefix) -> String
+                        | (Array[untyped] value, ?String prefix) -> String
+                        | (String value, ?nil prefix) -> String
+                        | (Hash[Symbol, Array[Hash[Symbol, Integer]]] value, ?nil prefix) -> String
+                        | (Array[Hash[Symbol, Integer]] value, ?String prefix) -> String
+                        | (Hash[untyped, untyped] value, ?nil prefix) -> String
+                        | (Hash[Symbol, String] value, ?nil prefix) -> String
+                        | (String value, ?String prefix) -> String
+                        | (Hash[String, String] value, ?nil prefix) -> String
+                        | (Hash[String, Hash[String, String]] value, ?nil prefix) -> String
+                        | (Hash[String, String] value, ?String prefix) -> String
+                        | (Hash[Symbol, Hash[Symbol, String]] value, ?nil prefix) -> String
+                        | (Hash[Symbol, String] value, ?String prefix) -> String
+
+  def build_multipart: (Hash[untyped, untyped] params, ?bool _first, ?bool multipart) -> nil
+                     | (Hash[Symbol, String] params, ?bool _first, ?bool multipart) -> nil
+                     | (Hash[String, String] params, ?bool _first, ?bool multipart) -> String?
+                     | (Hash[String, Array[Rack::Test::UploadedFile]] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[Symbol, Hash[Symbol, String]] params, ?bool _first, ?bool multipart) -> nil
+                     | (Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Hash[String, String] | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Rack::Test::UploadedFile | String] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[String] | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, String]]] params, ?bool _first, ?bool multipart) -> nil
+                     | (Hash[String, Array[Rack::Test::UploadedFile] | String] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile]] | Array[String]] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Rack::Test::UploadedFile | String]] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Hash[String, String] | String | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, untyped] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]]] | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile] | Hash[String, Array[String] | String]]] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, String]] | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, String | Rack::Test::UploadedFile] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, Rack::Test::UploadedFile | String]] | Array[String]] params, ?bool _first, ?bool multipart) -> bool
+                     | (Hash[String, Array[Hash[String, Array[String] | String]]] params, ?bool _first, ?bool multipart) -> String
+
+  private def normalize_multipart_params: (Hash[String, Array[Rack::Test::UploadedFile]] params, ?bool first) -> Hash[String, Array[Rack::Test::UploadedFile]]
+                                        | (Hash[String, String] params, ?bool first) -> Hash[String, String]
+                                        | (Hash[String, Hash[String, String]] params, ?bool first) -> Hash[String, String]
+                                        | (Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Rack::Test::UploadedFile | String]
+                                        | (Hash[String, Hash[String, String] | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Rack::Test::UploadedFile | String]
+                                        | (Hash[String, Rack::Test::UploadedFile | String] params, ?bool first) -> Hash[String, Rack::Test::UploadedFile | String]
+                                        | (Hash[String, Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Rack::Test::UploadedFile]
+                                        | (Hash[String, Array[String] | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Array[String] | Rack::Test::UploadedFile]
+                                        | (Hash[String, Array[Rack::Test::UploadedFile] | String] params, ?bool first) -> Hash[String, Array[Rack::Test::UploadedFile] | String]
+                                        | (Hash[String, String | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, String | Rack::Test::UploadedFile]
+                                        | (Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile]] | Array[String]] params, ?bool first) -> Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile]] | Array[String]]
+                                        | (Hash[String, Array[Rack::Test::UploadedFile | String]] params, ?bool first) -> Hash[String, Array[Rack::Test::UploadedFile | String]]
+                                        | (Hash[String, Hash[String, String] | String | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, String | Rack::Test::UploadedFile]
+                                        | (Hash[String, untyped] params, ?bool first) -> Hash[String, untyped]
+                                        | (Hash[String, Array[Hash[String, String]] | String] params, ?bool first) -> Hash[String, Array[Hash[String, String]] | String]
+                                        | (Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]]] params, ?bool first) -> Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]]]
+                                        | (Hash[String, Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]]] | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]] | Rack::Test::UploadedFile]
+                                        | (Hash[String, Array[String] | String] params, ?bool first) -> Hash[String, Array[String] | String]
+                                        | (Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile] | Hash[String, Array[String] | String]]] params, ?bool first) -> Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile] | Hash[String, Array[String] | String]]]
+                                        | (Hash[String, Array[Hash[String, String]] | Rack::Test::UploadedFile] params, ?bool first) -> Hash[String, Array[Hash[String, String]] | Rack::Test::UploadedFile]
+                                        | (Hash[String, Array[Hash[String, Rack::Test::UploadedFile | String]] | Array[String]] params, ?bool first) -> Hash[String, Array[Hash[String, Rack::Test::UploadedFile | String]] | Array[String]]
+                                        | (Hash[String, Array[Hash[String, Array[String] | String]]] params, ?bool first) -> Hash[String, Array[Hash[String, Array[String] | String]]]
+
+  private def _build_parts: (String buffer, Hash[String, Array[Rack::Test::UploadedFile]] parameters) -> File
+                          | (String buffer, Hash[String, String] parameters) -> Array[Array[String]]
+                          | (String buffer, Hash[String, Rack::Test::UploadedFile | String] parameters) -> File
+                          | (String buffer, Hash[String, Rack::Test::UploadedFile] parameters) -> File
+                          | (String buffer, Hash[String, Array[String] | Rack::Test::UploadedFile] parameters) -> File
+                          | (String buffer, Hash[String, Array[Rack::Test::UploadedFile] | String] parameters) -> File
+                          | (String buffer, Hash[String, String | Rack::Test::UploadedFile] parameters) -> File
+                          | (String buffer, Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile]] | Array[String]] parameters) -> singleton(Object)
+                          | (String buffer, Hash[String, Array[Rack::Test::UploadedFile | String]] parameters) -> File
+                          | (String buffer, Hash[String, untyped] parameters) -> bool
+                          | (String buffer, Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]] | Rack::Test::UploadedFile] parameters) -> File
+                          | (String buffer, Hash[String, Array[Hash[String, String]] | String] parameters) -> Array[Array[String] | Array[Hash[String, String]]]
+                          | (String buffer, Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile] | Hash[String, Array[String] | String]]] parameters) -> singleton(Object)
+                          | (String buffer, Hash[String, Array[String] | String] parameters) -> Array[Array[String]]
+                          | (String buffer, Hash[String, Array[Hash[String, String]] | Rack::Test::UploadedFile] parameters) -> File
+                          | (String buffer, Hash[String, Array[Hash[String, Rack::Test::UploadedFile | String]] | Array[String]] parameters) -> singleton(Object)
+                          | (String buffer, Hash[String, Array[Hash[String, Array[String] | String]]] parameters) -> Array[Array[Hash[String, Array[String] | String]]]
+
+  private def build_parts: (String buffer, Hash[String, Array[Rack::Test::UploadedFile]] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, String] parameters) -> String
+                         | (String buffer, Hash[String, Rack::Test::UploadedFile | String] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Rack::Test::UploadedFile] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Array[String] | Rack::Test::UploadedFile] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Array[Rack::Test::UploadedFile] | String] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile]] | Array[String]] parameters) -> bool
+                         | (String buffer, Hash[String, Array[Rack::Test::UploadedFile | String]] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, String | Rack::Test::UploadedFile] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, untyped] parameters) -> bool
+                         | (String buffer, Hash[String, Array[Hash[String, String] | Hash[String, Array[Hash[String, String]] | String]] | Rack::Test::UploadedFile] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Array[Hash[String, String | Rack::Test::UploadedFile] | Hash[String, Array[String] | String]]] parameters) -> bool
+                         | (String buffer, Hash[String, Array[Hash[String, String]] | Rack::Test::UploadedFile] parameters) -> singleton(Object)
+                         | (String buffer, Hash[String, Array[Hash[String, Rack::Test::UploadedFile | String]] | Array[String]] parameters) -> bool
+                         | (String buffer, Hash[String, Array[Hash[String, Array[String] | String]]] parameters) -> String
+
+  private def build_file_part: (String buffer, String parameter_name, Rack::Test::UploadedFile uploaded_file) -> String
+                             | (String buffer, String parameter_name, untyped uploaded_file) -> String
+
+  private def build_primitive_part: (String buffer, String parameter_name, String value) -> String
+end

data/examples/rack-test/out/rack/test.rbs

@@ -0,0 +1,3 @@
+module Rack::Test
+  def self.encoding_aware_strings?: () -> String
+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

@@ -9,32 +9,55 @@ module Orthoses
 
       def update_decl
         return unless @decl.respond_to?(:members)
-        uniq_map = {}
-        @decl.members.each do |member|
-          if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overload
-            # avoid to duplicate and keep order
-            uniq_map[Object.new] = member
-          else
-            key = member_key(member)
-            drop_member = uniq_map[key]
-            uniq_map[key] = member
-            if drop_member
-              Orthoses.logger.info("#{@decl.name} \"#{member.location.source}\" was droped since duplication")
-            end
-          end
-        end
+
+        uniq_map = uniq_members
+        drop_set_method_definition(uniq_map)
         drop_known_method_definition(uniq_map)
+
         @decl.members.replace(uniq_map.values)
       end
 
       private
 
+      def uniq_members
+        {}.tap do |uniq_map|
+          @decl.members.each do |member|
+            if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.overloading?
+              # avoid to duplicate and keep order
+              uniq_map[Object.new] = member
+            else
+              key = member_key(member)
+              drop_member = uniq_map[key]
+              uniq_map[key] = member
+              if drop_member
+                Orthoses.logger.info("#{@decl.name} \"#{member.location.source}\" was droped since duplication")
+              end
+            end
+          end
+        end
+      end
+
+      def drop_set_method_definition(uniq_map)
+        attr_accessors = uniq_map.values.grep(RBS::AST::Members::AttrAccessor)
+        attr_accessors.each do |member|
+          uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
+        end
+      end
+
       def drop_known_method_definition(uniq_map)
         decl_name = @decl.name.absolute!
         if m_entry = @env.class_decls[decl_name]
           m_entry.decls.each do |d|
-            d.decl.members.grep_v(RBS::AST::Members::LocationOnly).each do |member|
-              uniq_map.delete(member_key(member))
+            d.decl.members.each do |member|
+              case member
+              when RBS::AST::Members::LocationOnly
+                # ignore
+              when RBS::AST::Members::AttrAccessor
+                uniq_map.delete([RBS::AST::Members::MethodDefinition, member.name, member.kind])
+                uniq_map.delete([RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind])
+              else
+                uniq_map.delete(member_key(member))
+              end
             end
           end
         end
@@ -60,12 +83,11 @@ module Orthoses
         when RBS::AST::Members::Alias
           [RBS::AST::Members::MethodDefinition, member.new_name, member.kind]
         when RBS::AST::Members::AttrAccessor
-          # FIXME: how to check "#{member.name}=" ?
           [RBS::AST::Members::MethodDefinition, member.name, member.kind]
         when RBS::AST::Members::AttrReader
           [RBS::AST::Members::MethodDefinition, member.name, member.kind]
         when RBS::AST::Members::AttrWriter
-          [RBS::AST::Members::MethodDefinition, "#{member.name}=", member.kind]
+          [RBS::AST::Members::MethodDefinition, :"#{member.name}=", member.kind]
         else
           [member.class, member.name]
         end

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
@@ -15,9 +16,17 @@ module Orthoses
         end
       end
 
-      def initialize(constant_filter: nil, mixin_filter: nil, attribute_filter: nil)
+      def initialize(
+        method_definition_filter: nil,
+        alias_filter: nil,
+        constant_filter: nil,
+        mixin_filter: nil,
+        attribute_filter: nil
+      )
         @load_env = RBS::Environment.new
         @known_env = Utils.rbs_environment(cache: false)
+        @method_definition_filter = method_definition_filter
+        @alias_filter = alias_filter
         @constant_filter = constant_filter
         @mixin_filter = mixin_filter
         @attribute_filter = attribute_filter
@@ -33,7 +42,8 @@ module Orthoses
       def write_to(store:)
         each do |add_content|
           content = store[add_content.name]
-          content.header = add_content.header
+          content.header ||= add_content.header
+          content.comment ||= add_content.comment
           content.concat(add_content.body)
         end
       end
@@ -46,6 +56,7 @@ module Orthoses
         @load_env.class_decls.each do |type_name, m_entry|
           name = type_name.relative!.to_s
           content = Content.new(name: name)
+          content.comment = m_entry.primary.decl.comment&.string&.gsub(/^/, "# ")
           content.header = header_builder.build(entry: m_entry, name_hint: name)
           decls_to_lines(m_entry.decls.map(&:decl)).each do |line|
             content << line
@@ -93,9 +104,12 @@ module Orthoses
             when RBS::AST::Declarations::Constant
               next unless @constant_filter.nil? || @constant_filter.call(member)
             when RBS::AST::Members::MethodDefinition
+              next unless @method_definition_filter.nil? || @method_definition_filter.call(member)
               if last_visibility == :private && member.kind != :singleton_instance
                 member.instance_variable_set(:@visibility, :private)
               end
+            when RBS::AST::Members::Alias
+              next unless @alias_filter.nil? || @alias_filter.call(member)
             when RBS::AST::Members::Mixin
               next unless @mixin_filter.nil? || @mixin_filter.call(member)
             when RBS::AST::Members::Attribute

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

@@ -74,12 +74,52 @@ module Orthoses
     end
 
     def original_rbs
-      a = []
-      a << @comment if @comment
-      a << @header
-      a << "  #{@body.join("\n  ")}" if @body.length > 0
-      a << "end"
-      a.join("\n")
+      io = StringIO.new
+      io.puts @comment if @comment
+      io.puts @header
+      @body.each do |line|
+        io.puts "  #{line}"
+      end
+      io.puts "end"
+      io.string
+    end
+
+    def auto_header
+      env = Utils.rbs_environment
+      if entry = env.class_decls[TypeName(name).absolute!]
+        @header = Content::HeaderBuilder.new(env: env).build(entry: entry)
+        return
+      end
+
+      return unless @header.nil?
+
+      if interface?
+        self.header = "interface #{name}"
+        return
+      end
+
+      val = Object.const_get(name)
+
+      case val
+      when Class
+        superclass =
+          if val.superclass && val.superclass != Object
+            super_module_name = Utils.module_name(val.superclass)
+
+            if super_module_name && super_module_name != "Random::Base" # https://github.com/ruby/rbs/pull/977
+              " < ::#{super_module_name}#{temporary_type_params(super_module_name)}"
+            else
+              nil
+            end
+          else
+            nil
+          end
+        self.header = "class #{Utils.module_name(val)}#{type_params(name)}#{superclass}"
+      when Module
+        self.header = "module #{Utils.module_name(val)}#{type_params(name)}"
+      else
+        raise "#{val.inspect} is not class/module"
+      end
     end
 
     private
@@ -119,7 +159,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
@@ -132,44 +172,6 @@ module Orthoses
       raise
     end
 
-    def auto_header
-      env = Utils.rbs_environment
-      if entry = env.class_decls[TypeName(name).absolute!]
-        @header = Content::HeaderBuilder.new(env: env).build(entry: entry)
-        return
-      end
-
-      return unless @header.nil?
-
-      if interface?
-        self.header = "interface #{name}"
-        return
-      end
-
-      val = Object.const_get(name)
-
-      case val
-      when Class
-        superclass =
-          if val.superclass && val.superclass != Object
-            super_module_name = Utils.module_name(val.superclass)
-
-            if super_module_name && super_module_name != "Random::Base" # https://github.com/ruby/rbs/pull/977
-              " < ::#{super_module_name}#{temporary_type_params(super_module_name)}"
-            else
-              nil
-            end
-          else
-            nil
-          end
-        self.header = "class #{Utils.module_name(val)}#{type_params(name)}#{superclass}"
-      when Module
-        self.header = "module #{Utils.module_name(val)}#{type_params(name)}"
-      else
-        raise "#{val.inspect} is not class/module"
-      end
-    end
-
     def temporary_type_params(name)
       Utils.known_type_params(name)&.then do |params|
         if params.empty?

data/lib/orthoses/filter.rb

@@ -16,8 +16,8 @@ module Orthoses
     def call
       @loader.call.tap do |store|
         store.filter! do |name, content|
-          @block.call(name, content).tap do
-            Orthoses.logger.debug("Filter pass [#{name}]")
+          @block.call(name, content).tap do |bool|
+            Orthoses.logger.debug("[Filter] #{bool ? "Pass" : "Reject"} [#{name}]")
           end
         end
       end

data/lib/orthoses/rbs_prototype_rb.rb

@@ -1,11 +1,23 @@
 module Orthoses
   # Call `rbs prototype rb` and add to store
   #     use Orthoses::RBSPrototypeRB,
-  #       paths: Dir.glob("lib/**/*.rb")
+  #       paths: Dir.glob("lib/**/*.rb"),
+  #       method_definition_filter: ->(member) { false },
+  #       alias_filter: ->(member) { false }
   class RBSPrototypeRB
-    def initialize(loader, paths:, constant_filter: nil, mixin_filter: nil, attribute_filter: nil)
+    def initialize(
+      loader,
+      paths:,
+      method_definition_filter: nil,
+      alias_filter: nil,
+      constant_filter: nil,
+      mixin_filter: nil,
+      attribute_filter: nil
+    )
       @loader = loader
       @paths = paths
+      @method_definition_filter = method_definition_filter
+      @alias_filter = alias_filter
       @constant_filter = constant_filter
       @mixin_filter = mixin_filter
       @attribute_filter = attribute_filter
@@ -23,6 +35,8 @@ module Orthoses
           end
         end
         env = Orthoses::Content::Environment.new(
+          method_definition_filter: @method_definition_filter,
+          alias_filter: @alias_filter,
           constant_filter: @constant_filter,
           mixin_filter: @mixin_filter,
           attribute_filter: @attribute_filter,

data/lib/orthoses/trace/method.rb

@@ -169,8 +169,13 @@ module Orthoses
               kind: kind,
               location: nil,
               name: method_id,
-              overload: false,
-              types: types,
+              overloading: false,
+              overloads: types.map { |type|
+                RBS::AST::Members::MethodDefinition::Overload.new(
+                  annotations: [],
+                  method_type: type
+                )
+              },
               visibility: visibility
             )
           ]

data/lib/orthoses/utils.rb

@@ -50,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]]
@@ -80,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

data/lib/orthoses/version.rb

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

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

@@ -1,5 +1,14 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Middleware builder like the Rack
+#   Builder.new do
+#     use Orthoses::CreateFileByName
+#     use Orthoses::Constant
+#     use Orthoses::Mixin
+#     use Orthoses::Walk,
+#       root: "Foo"
+#     run ->() { require 'foo' }
+#   end
 class Orthoses::Builder
   def initialize: () ?{ () -> untyped } -> void
   def use: (untyped middleware, *untyped args, **untyped key) ?{ () -> untyped } -> untyped

data/sig/orthoses/call_tracer/capture.rbs

@@ -1,6 +1,6 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
-class Orthoses::CallTracer::Capture < ::Struct[untyped]
+class Orthoses::CallTracer::Capture
   def method: () -> Method
   def argument: () -> Hash[Symbol, untyped]
 end

data/sig/orthoses/call_tracer/lazy.rbs

@@ -1,6 +1,19 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# 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 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/duplication_checker.rbs

@@ -1,8 +1,11 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Check and drop duplication method, const etc...
 class Orthoses::Content::DuplicationChecker
   def initialize: (untyped decl, ?env: untyped?) -> void
   def update_decl: () -> (nil | untyped)
+  private def uniq_members: () -> untyped
+  private def drop_set_method_definition: (untyped uniq_map) -> untyped
   private def drop_known_method_definition: (untyped uniq_map) -> untyped
   private def member_key: (untyped member) -> untyped
 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

@@ -12,10 +12,10 @@ class Orthoses::Content
   def uniq!: () -> untyped
   def sort!: () -> untyped
   def original_rbs: () -> untyped
+  def auto_header: () -> (nil | 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)
   private def temporary_type_params: (untyped name) -> untyped
   private def type_params: (untyped name) -> untyped
   attr_reader name: String

data/sig/orthoses/filter.rbs

@@ -1,5 +1,10 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Filter current store.
+# filter stored key and value if proc return true
+#   use Orthoses::Filter do |name, content|
+#     Orthoses.rbs_defined_class?(name)
+#   end
 class Orthoses::Filter
   def initialize: (Orthoses::_Call loader) { (String, Orthoses::Content) -> boolish } -> void
   def call: () -> Orthoses::store