orthoses 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bde1745c71d6d30b7b45ce7f956a1c02f0d44353932c3743211aa1c05f58d39
-  data.tar.gz: bbe5b95a7665d39faab82b5f53e18cffd22962df1913f1c52698ea51c6045e2c
+  metadata.gz: e2915ad2b524676ac4ea67e61fcc90713bdaa8e79cb2ff01aeba74fe54b4885d
+  data.tar.gz: 0f8823a7e88b4030eb6554ac9f35a068730ac944378832f923c99cf3b4e8e6be
 SHA512:
-  metadata.gz: 496d255f99751ac854e5b05ecac69b1e0dc7dbb5fca53bf99d6d622e2dbb154af643de7bf8de8190dca15ff1933fac35c17735da9285532a8a3246d7002836cd
-  data.tar.gz: 56c77cf9074eeb75547c1be3868e9843b0d5337400d2248592879f76fd6cc14f99660d8dbbf593c1d66bac1152e1dafbaa4820ea45a49f5f47945027ce45d53a
+  metadata.gz: '06038e9dd28433a1c9358915720fe942f597caee2d68651ce7c54b47136633cc1d55288c7b8053766f393bacda9974b1ee662337f80d78b0796d405453b2cc32'
+  data.tar.gz: 92074fd8665515453126f44627604f7fd3da1dcb7a85ec25b1ef51424c6797f9b1f67925d2349db05b7ce7aace06dc7f3f2d2be737cfb5399383bed4f846b11f

data/Gemfile

@@ -9,6 +9,7 @@ gem "rbs"
 gem "rake", "~> 13.0"
 gem "rgot", "~> 1.1"
 gem "activesupport"
+gem "debug"
 
 group :steep do
   gem "steep", "1.4.0.dev.2"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    orthoses (1.6.0)
+    orthoses (1.7.0)
       rbs (~> 3.0)
 
 GEM
@@ -15,10 +15,16 @@ GEM
     ast (2.4.2)
     concurrent-ruby (1.2.2)
     csv (3.2.6)
+    debug (1.8.0)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
     ffi (1.15.5)
-    fileutils (1.7.0)
-    i18n (1.12.0)
+    fileutils (1.7.1)
+    i18n (1.13.0)
       concurrent-ruby (~> 1.0)
+    io-console (0.6.0)
+    irb (1.6.4)
+      reline (>= 0.3.0)
     json (2.6.3)
     language_server-protocol (3.17.0.3)
     listen (3.8.0)
@@ -26,8 +32,8 @@ GEM
       rb-inotify (~> 0.9, >= 0.9.10)
     logger (1.5.3)
     minitest (5.18.0)
-    parallel (1.22.1)
-    parser (3.2.1.1)
+    parallel (1.23.0)
+    parser (3.2.2.1)
       ast (~> 2.4.1)
     pathname (0.2.1)
     rainbow (3.1.1)
@@ -35,7 +41,9 @@ GEM
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (3.0.4)
+    rbs (3.1.0)
+    reline (0.3.3)
+      io-console (~> 0.5)
     rgot (1.3.0)
     securerandom (0.2.2)
     steep (1.4.0.dev.2)
@@ -62,10 +70,12 @@ GEM
     unicode-display_width (2.4.2)
 
 PLATFORMS
-  ruby
+  x86_64-darwin-21
+  x86_64-linux
 
 DEPENDENCIES
   activesupport
+  debug
   orthoses!
   rake (~> 13.0)
   rbs

data/examples/rack-test/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: ../..
   specs:
-    orthoses (1.4.0)
-      rbs (~> 2.0)
+    orthoses (1.6.0)
+      rbs (~> 3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -13,7 +13,7 @@ GEM
       minitest (> 5)
     rack (3.0.2)
     rake (13.0.6)
-    rbs (2.8.1)
+    rbs (3.0.4)
 
 PLATFORMS
   arm64-darwin-21

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

@@ -0,0 +1,28 @@
+class Rack::Test::Cookie
+  attr_reader name: String
+  attr_reader value: String
+  attr_reader raw: String
+  private def initialize: (String raw, ?URI::Generic uri, ?String default_host) -> void
+                        | (String raw, ?nil uri, ?String default_host) -> void
+                        | (String raw, ?URI::HTTPS uri, ?String default_host) -> void
+                        | (String raw, ?URI::HTTP uri, ?String default_host) -> void
+  def domain: () -> String
+  def secure?: () -> bool
+  def valid?: (URI::Generic uri) -> (bool | URI::RFC3986_Parser)
+            | (URI::HTTPS uri) -> bool
+            | (nil uri) -> nil
+            | (URI::HTTP uri) -> bool
+  private def default_uri: () -> Array[String?]
+  def http_only?: () -> bool
+  def empty?: () -> bool
+  def to_h: () -> Hash[String, String | bool]
+  def expires: () -> Time?
+  def expired?: () -> Integer?
+  def matches?: (URI::HTTPS uri) -> (Array[Integer] | bool)
+              | (URI::Generic uri) -> (Array[Integer] | bool)
+              | (URI::HTTP uri) -> (Array[Integer] | bool)
+  def path: () -> String
+  def replaces?: (Rack::Test::Cookie other) -> String
+  def <=>: (Rack::Test::Cookie other) -> String
+  alias to_hash to_h
+end

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

@@ -0,0 +1,28 @@
+class Rack::Test::CookieJar
+  private def initialize: (?Array[untyped] cookies, ?String default_host) -> void
+  private def each_cookie_for: (URI::Generic uri) -> (Array[untyped] | String | bool)
+                             | (URI::HTTP uri) -> (Array[untyped] | String | bool)
+                             | (nil uri) -> String
+                             | (URI::HTTPS uri) -> (Array[untyped] | String)
+  def for: (URI::Generic uri) -> (Array[Rack::Test::Cookie] | String | Time)
+         | (URI::HTTP uri) -> (Array[Rack::Test::Cookie] | String | Time)
+         | (nil uri) -> String
+         | (URI::HTTPS uri) -> (Array[Rack::Test::Cookie] | String)
+  def merge: (nil raw_cookies, ?URI::Generic uri) -> nil
+           | (String raw_cookies, ?URI::Generic uri) -> Rack::QueryParser::Params
+           | (nil raw_cookies, ?URI::HTTP uri) -> nil
+           | (String raw_cookies, ?nil uri) -> Array[nil]
+           | (nil raw_cookies, ?URI::HTTPS uri) -> nil
+           | (Array[String] raw_cookies, ?URI::Generic uri) -> Rack::QueryParser::Params
+           | (String raw_cookies, ?URI::HTTPS uri) -> Rack::QueryParser::Params
+           | (String raw_cookies, ?URI::HTTP uri) -> Rack::QueryParser::Params
+           | (Array[String] raw_cookies, ?nil uri) -> Array[nil]
+  def []: (String name) -> String?
+        | (Symbol name) -> String
+  private def initialize_copy: (Rack::Test::CookieJar other) -> Array[untyped]
+  def <<: (Rack::Test::Cookie new_cookie) -> (Array[Rack::Test::Cookie] | String)
+  def []=: (String name, String value) -> String
+  def to_hash: () -> (Hash[untyped, untyped] | String)
+  def get_cookie: (String name) -> String?
+  def delete: (String name) -> String
+end

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

@@ -0,0 +1,13 @@
+class Rack::Test::FakeApp
+  private def handle: (Hash[String, Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+                    | (Hash[String, Hash[Symbol, Symbol] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+                    | (Hash[String, Hash[Symbol, String] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+                    | (Hash[String, Hash[untyped, untyped] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+                    | (Hash[String, Hash[String, String] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+  def call: (Hash[String, Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+          | (Hash[String, Hash[Symbol, Symbol] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+          | (Hash[String, Hash[Symbol, String] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+          | (Hash[String, Hash[untyped, untyped] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+          | (Hash[String, Hash[String, String] | Rack::Lint::Wrapper::InputWrapper | Rack::Lint::Wrapper::ErrorWrapper | String | bool] env) -> nil
+  private def new_cookie_count: (Rack::Request req) -> Hash[untyped, untyped]
+end

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

@@ -0,0 +1,8 @@
+class Rack::Test::InputRewinder
+  private def initialize: (Rack::Lint app) -> void
+  def call: (Hash[String, StringIO | String | bool] env) -> Integer
+          | (Hash[String, Hash[Symbol, Symbol] | StringIO | String | bool] env) -> Integer
+          | (Hash[String, Hash[Symbol, String] | StringIO | String | bool] env) -> Integer
+          | (Hash[String, Hash[untyped, untyped] | StringIO | String | bool] env) -> Integer
+          | (Hash[String, Hash[String, String] | StringIO | String | bool] env) -> Integer
+end

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

@@ -0,0 +1,98 @@
+module Rack::Test::Methods
+  attr_accessor _rack_test_current_session: Rack::Test::Session?
+
+  def build_rack_test_session: (Symbol _name) -> (Rack::Test::InputRewinder | Proc | Rack::Test::Session)
+                             | (bool _name) -> Rack::Test::InputRewinder
+                             | (nil _name) -> Rack::Test::InputRewinder
+
+  def rack_test_session: (?Symbol name) -> (Rack::Test::Session | String)
+                       | (?bool name) -> Rack::Test::Session
+                       | (?nil name) -> Rack::Test::Session
+
+  def current_session: () -> Rack::Test::Session
+
+  def request: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> (Array[nil] | Rack::Test::Session)
+             | (*Array[Hash[String, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> (Array[nil] | Rack::Test::Session)
+             | (*Array[Hash[Symbol, Hash[String, String]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[untyped, untyped]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[String, String] | Symbol] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[Symbol, Hash[Symbol, String]]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Symbol] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[Symbol, Hash[Symbol, String]] | Symbol] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Symbol | String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol | String, Hash[String, String] | Symbol | String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[String, String] | Symbol | bool] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, Hash[Symbol, Integer]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[Symbol, bool] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[String, Hash[Symbol, Symbol]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Array[nil]
+
+  def last_request: (*Array[untyped] args, **untyped) ?{ (*untyped) -> untyped } -> (Rack::Request | Rack::Test::Session)
+
+  def get: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> (Array[nil] | Rack::Test::Session)
+         | (*Array[Hash[String, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> (Array[nil] | Rack::Test::Session)
+         | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[Hash[Symbol, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[Hash[String, Hash[String, String]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[(Hash[String, String] | String)?] args, **untyped) ?{ (*untyped) -> untyped } -> Array[nil]
+
+  def last_response: (*Array[untyped] args, **untyped) ?{ (*untyped) -> untyped } -> (Rack::MockResponse | Rack::Test::Session)
+
+  def options: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+             | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def custom_request: (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+                    | (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def delete: (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+            | (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+            | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+            | (*Array[Hash[Symbol, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def patch: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+           | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+           | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def put: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def post: (*Array[Hash[String, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[Symbol, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Array[Rack::Test::UploadedFile]] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Hash[String, String] | Rack::Test::UploadedFile] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Rack::Test::UploadedFile | String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Rack::Test::UploadedFile] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Rack::Test::UploadedFile] | Hash[String, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[String, Array[String] | Rack::Test::UploadedFile] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def env: (*Array[Hash[Symbol, String] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+         | (*Array[Hash[Symbol, Symbol] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Hash[Symbol, Symbol]
+         | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Hash[Symbol, String]
+
+  def follow_redirect!: (*Array[untyped] args, **untyped) ?{ (*untyped) -> untyped } -> (Rack::Test::Session | String)
+
+  def header: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> (Rack::Test::Session | String)
+            | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> String
+
+  def head: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[String?] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+          | (*Array[Hash[untyped, untyped] | String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def basic_authorize: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def set_cookie: (*Array[String] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+                | (*Array[Array[String]] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::Session
+
+  def with_session: (Symbol name) -> Rack::Test::Session?
+
+  def clear_cookies: (*Array[untyped] args, **untyped) ?{ (*untyped) -> untyped } -> Rack::Test::CookieJar
+
+  alias rack_mock_session rack_test_session
+end

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

@@ -0,0 +1,186 @@
+class Rack::Test::Session
+  attr_accessor cookie_jar: Rack::Test::CookieJar
+  def clear_cookies: () -> Rack::Test::CookieJar
+  private def initialize: (Rack::Test::InputRewinder app, ?String default_host) -> void
+                        | (Proc app, ?String default_host) -> void
+  def self.new: (Rack::Test::InputRewinder app, ?String default_host) -> Rack::Test::Session
+              | (Proc app, ?String default_host) -> Rack::Test::Session
+              | (Rack::Test::Session app, ?String default_host) -> Rack::Test::Session
+  private def parse_uri: (String path, Hash[untyped, untyped] env) -> Array[String?]
+                       | (String path, Hash[String, String] env) -> Array[String?]
+                       | (String path, Hash[Symbol, bool] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[String, String]] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[untyped, untyped]] env) -> Array[String?]
+                       | (String path, Hash[Symbol, String] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[String, String] | Symbol] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[Symbol, Hash[Symbol, String]]] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Symbol] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[Symbol, Hash[Symbol, String]] | Symbol] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Symbol | String] env) -> Array[String?]
+                       | (String path, Hash[Symbol | String, Hash[String, String] | Symbol | String] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[String, String] | Symbol | bool] env) -> Array[String?]
+                       | (String path, Hash[Symbol, Hash[Symbol, Integer]] env) -> Array[String?]
+                       | (String path, Hash[String, Hash[Symbol, Symbol]] env) -> Array[String?]
+                       | (String path, Hash[String, Hash[untyped, untyped] | String] env) -> Array[String?]
+                       | (String path, Hash[String, Hash[String, String]] env) -> Array[String?]
+  def request: (String uri, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> String?
+             | (String uri, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[String, String]] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[untyped, untyped]] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, String] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[String, String] | Symbol] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[Symbol, Hash[Symbol, String]]] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Symbol] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[Symbol, Hash[Symbol, String]] | Symbol] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Symbol | String] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol | String, Hash[String, String] | Symbol | String] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[String, String] | Symbol | bool] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, Hash[Symbol, Integer]] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> nil
+             | (String uri, ?Hash[String, Hash[Symbol, Symbol]] env) ?{ (*untyped) -> untyped } -> nil
+  private def env_for: (URI::Generic uri, Hash[untyped, untyped] env) -> (singleton(URI::Generic) | String)
+                     | (URI::Generic uri, Hash[Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, String?] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String | Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::Generic)
+                     | (URI::HTTP uri, Hash[Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::HTTP)
+                     | (URI::Generic uri, Hash[Symbol, Hash[untyped, untyped] | bool | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[Symbol, String] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, String] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Array[Rack::Test::UploadedFile]] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String, String] env) -> (singleton(URI::Generic) | String)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, String]] env) -> singleton(URI::Generic)
+                     | (URI::HTTPS uri, Hash[untyped, untyped] env) -> singleton(URI::HTTPS)
+                     | (URI::Generic uri, Hash[Symbol, Hash[untyped, untyped]] env) -> singleton(URI::Generic)
+                     | (URI::HTTP uri, Hash[untyped, untyped] env) -> singleton(URI::HTTP)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, String] | Symbol] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[Symbol, Hash[Symbol, String]]] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Symbol] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[Symbol, Hash[Symbol, String]] | Symbol] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Symbol | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol | String, Hash[String, String] | Symbol | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, String] | Symbol | bool] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[Symbol, Integer]] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, bool] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Hash[String, String] | Rack::Test::UploadedFile] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Rack::Test::UploadedFile | String] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Rack::Test::UploadedFile] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String | Symbol, Hash[String, Rack::Test::UploadedFile] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Array[String] | Rack::Test::UploadedFile] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String, Hash[Symbol, Symbol]] env) -> singleton(URI::Generic)
+                     | (URI::HTTP uri, Hash[String | Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::HTTP)
+                     | (URI::HTTPS uri, Hash[String | Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::HTTPS)
+                     | (URI::Generic uri, Hash[Symbol, Hash[String, Hash[String, String]] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String | Symbol, Hash[String, String] | String] env) -> singleton(URI::Generic)
+                     | (URI::Generic uri, Hash[String | Symbol, String?] env) -> singleton(URI::Generic)
+                     | (URI::HTTPS uri, Hash[Symbol, Hash[String, String] | String] env) -> singleton(URI::HTTPS)
+                     | (URI::HTTPS uri, Hash[Symbol, Hash[untyped, untyped] | String] env) -> singleton(URI::HTTPS)
+                     | (URI::HTTP uri, Hash[Symbol, Hash[String, String] | String] env) -> singleton(URI::HTTP)
+  private def process_request: (URI::Generic uri, Hash[String, StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::HTTP uri, Hash[String, StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::HTTPS uri, Hash[String, StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::Generic uri, Hash[String, Hash[Symbol, Symbol] | StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::Generic uri, Hash[String, Hash[Symbol, String] | StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::HTTP uri, Hash[String, Hash[untyped, untyped] | StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::HTTPS uri, Hash[String, Hash[untyped, untyped] | StringIO | String | bool] env) -> Rack::Test::CookieJar
+                             | (URI::Generic uri, Hash[String, Hash[String, String] | StringIO | String | bool] env) -> Rack::Test::CookieJar
+  private def close_body: (Rack::Lint::Wrapper body) -> nil
+                        | (untyped body) -> nil
+                        | (Array[String] body) -> nil
+                        | (Array[untyped] body) -> nil
+  def last_response: () -> Rack::MockResponse
+  def last_request: () -> Rack::Request
+  def after_request: () ?{ (*untyped) -> untyped } -> Array[Proc]
+  def custom_request: (String verb, String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> String?
+                    | (String verb, String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?String params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[Symbol, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> String?
+                    | (String verb, String uri, ?Hash[String, Array[Rack::Test::UploadedFile]] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Hash[String, String] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Rack::Test::UploadedFile | String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Rack::Test::UploadedFile] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Array[String] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[untyped, untyped] params, ?Hash[String, Hash[untyped, untyped] | String] env) ?{ (*untyped) -> untyped } -> String
+                    | (String verb, String uri, ?Hash[String, String] params, ?Hash[String, Hash[untyped, untyped] | String] env) ?{ (*untyped) -> untyped } -> String
+                    | (String verb, String uri, ?Hash[untyped, untyped] params, ?Hash[String, Hash[String, String]] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, Hash[String, String]] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?Hash[String, String] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> nil
+                    | (String verb, String uri, ?nil params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> nil
+  def get: (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[String, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, Hash[String, String]] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[Symbol, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[String, Hash[String, String]] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[String, String] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?nil params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  private def append_query_params: (Array[nil] query_array, Hash[untyped, untyped] query_params) -> Array[String?]
+                                 | (Array[String] query_array, Hash[untyped, untyped] query_params) -> Array[String]
+                                 | (Array[nil] query_array, Hash[String, String] query_params) -> String
+                                 | (Array[String] query_array, String query_params) -> Hash[untyped, untyped]
+                                 | (Array[String?] query_array, Hash[String, String] query_params) -> String
+                                 | (Array[String] query_array, Hash[Symbol, Hash[Symbol, String]] query_params) -> String
+                                 | (Array[String] query_array, Hash[Symbol, Integer] query_params) -> String
+                                 | (Array[nil] query_array, Hash[Symbol, String] query_params) -> String
+                                 | (Array[nil] query_array, Hash[String, Hash[String, String]] query_params) -> String
+  def restore_state: () -> nil
+  def options: (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+             | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+             | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+             | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  def delete: (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+            | (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+            | (String uri, ?String params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+            | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+            | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+            | (String uri, ?Hash[Symbol, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  def patch: (String uri, ?String params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+           | (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+           | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+           | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+           | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  def put: (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+         | (String uri, ?String params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  def post: (String uri, ?Hash[String, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[Symbol, String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?String params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Array[Rack::Test::UploadedFile]] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Hash[String, Hash[String, String]] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Hash[String, String] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Rack::Test::UploadedFile | String] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Rack::Test::UploadedFile] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[String, Array[String] | Rack::Test::UploadedFile] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  private def multipart_content_type: (Hash[String | Symbol, bool | String] env) -> String
+                                    | (Hash[String | Symbol, bool | String | Symbol] env) -> String
+  def env: (String name, Hash[Symbol, String] value) -> Hash[Symbol, String]
+         | (String name, Hash[Symbol, Symbol] value) -> Hash[Symbol, Symbol]
+         | (String name, nil value) -> (Hash[Symbol, String] | String)
+         | (String name, String value) -> String
+  def follow_redirect!: () -> bool?
+  def header: (String name, String value) -> String
+            | (String name, nil value) -> String
+  def head: (String uri, ?Hash[untyped, untyped] params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?nil params, ?Hash[untyped, untyped] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[untyped, untyped] params, ?Hash[String, String] env) ?{ (*untyped) -> untyped } -> Array[nil]
+          | (String uri, ?Hash[untyped, untyped] params, ?Hash[Symbol, bool] env) ?{ (*untyped) -> untyped } -> Array[nil]
+  def basic_authorize: (String username, String password) -> String
+  def set_cookie: (String cookie, ?nil uri) -> Rack::Test::CookieJar
+                | (String cookie, ?URI::Generic uri) -> Rack::Test::CookieJar
+                | (Array[String] cookie, ?nil uri) -> Rack::Test::CookieJar
+end

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

@@ -0,0 +1,18 @@
+class Rack::Test::UploadedFile
+  attr_reader tempfile: Tempfile?
+  attr_reader original_filename: String
+  attr_accessor content_type: String
+  private def initialize_from_file_path: (String path) -> singleton(File)
+  private def initialize: (String content, ?String content_type, ?bool binary, ?original_filename: nil) -> void
+                        | (StringIO content, ?String content_type, ?bool binary, ?original_filename: String) -> void
+                        | (String content, ?String content_type, ?bool binary, ?original_filename: String) -> void
+                        | (StringIO content, ?String content_type, ?bool binary, ?original_filename: nil) -> void
+  def self.finalize: (Tempfile file) -> Proc
+  private def respond_to_missing?: (Symbol method_name, ?bool include_private) -> Tempfile?
+  def method_missing: (Symbol method_name, *Array[untyped] args) ?{ (*untyped) -> untyped } -> Tempfile
+                    | (Symbol method_name, *Array[Encoding] args) ?{ (*untyped) -> untyped } -> Tempfile
+  def append_to: (String buffer) -> Tempfile
+  private def initialize_from_stringio: (StringIO stringio) -> StringIO
+  def path: () -> Tempfile
+  def self.actually_finalize: (Tempfile file) -> nil
+end

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/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.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
+
+        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

@@ -16,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
@@ -34,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
@@ -47,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
@@ -94,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.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
@@ -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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Orthoses
-  VERSION = "1.6.0"
+  VERSION = "1.7.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,5 +1,17 @@
 # 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: (String name) ?{ () -> untyped } -> untyped

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.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

data/sig/orthoses/lazy_trace_point.rbs

@@ -1,5 +1,13 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# TracePoint wrapper that allows setting hooks
+# even if the target is undefined
+#   LazyTracePoint.new(:call) do |tp|
+#     ...
+#   end.enable(target: 'Class#class_attribute') do
+#     require 'active_support/core_ext/class/attribute'
+#     ...
+#   end
 class Orthoses::LazyTracePoint < ::TracePoint
   def method_added: (untyped id) -> untyped
   def singleton_method_added: (untyped id) -> untyped

data/sig/orthoses/outputable/avoid_recursive_ancestor_error.rbs

@@ -1,5 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# AvoidRecursiveAncestorError is an internal middleware
+# It's using on orthoses/outputable.rb
 class Orthoses::Outputable::AvoidRecursiveAncestorError
   def initialize: (Orthoses::_Call loader) -> void
   def call: () -> Orthoses::store

data/sig/orthoses/outputable/constantizable_filter.rbs

@@ -1,5 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Constantizable is an internal middleware
+# It's using on orthoses/outputable.rb
 class Orthoses::Outputable::ConstantizableFilter
   def initialize: (untyped loader) -> void
   def call: () -> untyped

data/sig/orthoses/outputable/uniq_content_body.rbs

@@ -1,5 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# UniqContentBody is an internal middleware
+# It's using on orthoses/outputable.rb
 class Orthoses::Outputable::UniqContentBody
   def initialize: (untyped loader) -> void
   def call: () -> untyped

data/sig/orthoses/pp.rbs

@@ -1,5 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Debug current stored values
+#   use Orthoses::PP
 class Orthoses::PP
   def initialize: (untyped loader) -> void
   def call: () -> untyped

data/sig/orthoses/rbs_prototype_rb.rbs

@@ -1,5 +1,10 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Call `rbs prototype rb` and add to store
+#     use Orthoses::RBSPrototypeRB,
+#       paths: Dir.glob("lib/**/*.rb"),
+#       method_definition_filter: ->(member) { false },
+#       alias_filter: ->(member) { false }
 class Orthoses::RBSPrototypeRB
   def initialize: (Orthoses::_Call loader, paths: Array[_ToS], ?constant_filter: Orthoses::Content::Environment::constant_filter?, ?mixin_filter: Orthoses::Content::Environment::mixin_filter?, ?attribute_filter: Orthoses::Content::Environment::attribute_filter?) -> void
   def call: () -> Orthoses::store

data/sig/orthoses/rbs_prototype_runtime.rbs

@@ -1,5 +1,8 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Call `rbs prototype runtime` and add to store
+#     use Orthoses::RBSPrototypeRuntime,
+#       patterns: ['Foo::*']
 class Orthoses::RBSPrototypeRuntime
   def initialize: (untyped loader, patterns: untyped) -> void
   def call: () -> untyped

data/sig/orthoses/sort.rbs

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

data/sig/orthoses/store.rbs

@@ -1,5 +1,7 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# Internal middleware for return store object
+# Builder set this middleware on last stack by default
 class Orthoses::Store
   def initialize: (untyped loader) -> void
   def call: () -> untyped

data/sig/orthoses/tap.rbs

@@ -1,5 +1,8 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# use Orthoses::Tap do |store|
+#   store["Foo::Bar"] << "def baz: () -> void"
+# end
 class Orthoses::Tap
   def initialize: (Orthoses::_Call loader) -> void
   def call: () -> Orthoses::store

data/sig/orthoses/utils/type_list.rbs

@@ -1,5 +1,6 @@
 # THIS IS GENERATED CODE from `$ rake generate_self_sig`
 
+# internal
 class Orthoses::Utils::TypeList
   def initialize: (untyped types) -> void
   def inject: () -> untyped

data/sig/orthoses.rbs

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orthoses
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-15 00:00:00.000000000 Z
+date: 2023-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -41,6 +41,15 @@ files:
 - examples/rack-test/Gemfile.lock
 - examples/rack-test/Rakefile
 - examples/rack-test/generate.rb
+- examples/rack-test/out/rack/test.rbs
+- examples/rack-test/out/rack/test/cookie.rbs
+- examples/rack-test/out/rack/test/cookie_jar.rbs
+- examples/rack-test/out/rack/test/fake_app.rbs
+- examples/rack-test/out/rack/test/input_rewinder.rbs
+- examples/rack-test/out/rack/test/methods.rbs
+- examples/rack-test/out/rack/test/session.rbs
+- examples/rack-test/out/rack/test/uploaded_file.rbs
+- examples/rack-test/out/rack/test/utils.rbs
 - examples/simple_middleware.rb
 - examples/simple_middleware.rbs
 - lib/orthoses.rb
@@ -156,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Framework for Generate RBS