muina 0.2.7 → 0.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (159) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +25 -0
  3. data/README.md +0 -35
  4. data/lib/muina/maybe/none.rb +57 -0
  5. data/lib/muina/maybe/some.rb +61 -0
  6. data/lib/muina/maybe.rb +13 -0
  7. data/lib/muina/version.rb +1 -2
  8. data/lib/muina.rb +0 -32
  9. metadata +24 -226
  10. data/.github/workflows/main.yml +0 -16
  11. data/.gitignore +0 -5
  12. data/.mutant.yml +0 -38
  13. data/.rspec +0 -4
  14. data/.rubocop.yml +0 -172
  15. data/.ruby-version +0 -1
  16. data/.simplecov +0 -14
  17. data/CHANGELOG.md +0 -38
  18. data/Gemfile +0 -34
  19. data/Gemfile.lock +0 -265
  20. data/Guardfile +0 -24
  21. data/Rakefile +0 -13
  22. data/SECURITY.md +0 -14
  23. data/bin/bundle +0 -114
  24. data/bin/console +0 -15
  25. data/bin/flay +0 -29
  26. data/bin/flog +0 -29
  27. data/bin/guard +0 -29
  28. data/bin/irb +0 -29
  29. data/bin/lefthook +0 -29
  30. data/bin/mutant +0 -29
  31. data/bin/parlour +0 -29
  32. data/bin/rake +0 -29
  33. data/bin/rspec +0 -29
  34. data/bin/rubocop +0 -29
  35. data/bin/setup +0 -8
  36. data/bin/srb +0 -29
  37. data/bin/srb-rbi +0 -29
  38. data/bin/tapioca +0 -29
  39. data/exe/muina +0 -11
  40. data/lefthook.yml +0 -39
  41. data/lib/muina/action/params_factory.rb +0 -17
  42. data/lib/muina/action/step/command.rb +0 -31
  43. data/lib/muina/action/step/failure.rb +0 -18
  44. data/lib/muina/action/step/query.rb +0 -31
  45. data/lib/muina/action/step/result.rb +0 -51
  46. data/lib/muina/action/step.rb +0 -13
  47. data/lib/muina/action.rb +0 -73
  48. data/lib/muina/any.rb +0 -7
  49. data/lib/muina/classes.rb +0 -7
  50. data/lib/muina/module.rb +0 -6
  51. data/lib/muina/parameters.rb +0 -7
  52. data/lib/muina/params.rb +0 -19
  53. data/lib/muina/private_creation.rb +0 -12
  54. data/lib/muina/result/factory.rb +0 -37
  55. data/lib/muina/result/failure.rb +0 -31
  56. data/lib/muina/result/null.rb +0 -25
  57. data/lib/muina/result/success.rb +0 -31
  58. data/lib/muina/result.rb +0 -17
  59. data/lib/muina/service.rb +0 -37
  60. data/lib/muina/symbol_hash.rb +0 -7
  61. data/lib/muina/unit.rb +0 -10
  62. data/lib/muina/untyped_array.rb +0 -7
  63. data/lib/muina/untyped_hash.rb +0 -7
  64. data/lib/muina/value.rb +0 -16
  65. data/muina.gemspec +0 -35
  66. data/rbi/muina.rbi +0 -268
  67. data/sorbet/config +0 -2
  68. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +0 -5045
  69. data/sorbet/rbi/gems/actionview@6.1.4.rbi +0 -2416
  70. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +0 -3778
  71. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  72. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +0 -322
  73. data/sorbet/rbi/gems/builder@3.2.4.rbi +0 -8
  74. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -18
  75. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -8
  76. data/sorbet/rbi/gems/colorize@0.8.1.rbi +0 -39
  77. data/sorbet/rbi/gems/commander@4.6.0.rbi +0 -8
  78. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +0 -2403
  79. data/sorbet/rbi/gems/crass@1.0.6.rbi +0 -123
  80. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -185
  81. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  82. data/sorbet/rbi/gems/erubi@1.10.0.rbi +0 -36
  83. data/sorbet/rbi/gems/erubis@2.7.0.rbi +0 -8
  84. data/sorbet/rbi/gems/faker@2.18.0.rbi +0 -2469
  85. data/sorbet/rbi/gems/ffi@1.15.3.rbi +0 -8
  86. data/sorbet/rbi/gems/flay@2.12.1.rbi +0 -178
  87. data/sorbet/rbi/gems/flog@4.6.4.rbi +0 -70
  88. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  89. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -49
  90. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -233
  91. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +0 -66
  92. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +0 -69
  93. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -617
  94. data/sorbet/rbi/gems/highline@2.0.3.rbi +0 -8
  95. data/sorbet/rbi/gems/i18n@1.8.10.rbi +0 -616
  96. data/sorbet/rbi/gems/io-console@0.5.9.rbi +0 -8
  97. data/sorbet/rbi/gems/irb@1.3.6.rbi +0 -452
  98. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +0 -8
  99. data/sorbet/rbi/gems/listen@3.6.0.rbi +0 -476
  100. data/sorbet/rbi/gems/loofah@2.10.0.rbi +0 -223
  101. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -431
  102. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -8
  103. data/sorbet/rbi/gems/minitest@5.14.4.rbi +0 -344
  104. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +0 -8
  105. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +0 -8
  106. data/sorbet/rbi/gems/mutant@0.10.32.rbi +0 -4154
  107. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -88
  108. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +0 -1422
  109. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -331
  110. data/sorbet/rbi/gems/parallel@1.20.1.rbi +0 -113
  111. data/sorbet/rbi/gems/parlour@6.0.1.rbi +0 -1726
  112. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1683
  113. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +0 -24
  114. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +0 -393
  115. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -8
  116. data/sorbet/rbi/gems/racc@1.5.2.rbi +0 -47
  117. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +0 -272
  118. data/sorbet/rbi/gems/rack@2.2.3.rbi +0 -1618
  119. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +0 -92
  120. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +0 -183
  121. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  122. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -808
  123. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  124. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  125. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  126. data/sorbet/rbi/gems/reline@0.2.6.rbi +0 -662
  127. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  128. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2509
  129. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  130. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  131. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  132. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  133. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +0 -2194
  134. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +0 -899
  135. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +0 -118
  136. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +0 -1805
  137. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +0 -288
  138. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +0 -13197
  139. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  140. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +0 -4528
  141. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +0 -157
  142. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +0 -359
  143. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -28
  144. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  145. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  146. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  147. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +0 -42
  148. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +0 -8
  149. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +0 -17
  150. data/sorbet/rbi/gems/spoom@1.1.1.rbi +0 -1193
  151. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +0 -1826
  152. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -838
  153. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +0 -856
  154. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +0 -26
  155. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -2037
  156. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +0 -173
  157. data/sorbet/rbi/todo.rbi +0 -8
  158. data/sorbet/rbi/typed_params.rbi +0 -7
  159. data/sorbet/tapioca/require.rb +0 -16
@@ -1,1618 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `rack` gem.
3
- # Please instead update this file by running `bin/tapioca sync`.
4
-
5
- # typed: true
6
-
7
- module Rack
8
- class << self
9
- def release; end
10
- def version; end
11
- end
12
- end
13
-
14
- module Rack::Auth; end
15
-
16
- class Rack::Auth::AbstractHandler
17
- def initialize(app, realm = T.unsafe(nil), &authenticator); end
18
-
19
- def realm; end
20
- def realm=(_arg0); end
21
-
22
- private
23
-
24
- def bad_request; end
25
- def unauthorized(www_authenticate = T.unsafe(nil)); end
26
- end
27
-
28
- class Rack::Auth::AbstractRequest
29
- def initialize(env); end
30
-
31
- def params; end
32
- def parts; end
33
- def provided?; end
34
- def request; end
35
- def scheme; end
36
- def valid?; end
37
-
38
- private
39
-
40
- def authorization_key; end
41
- end
42
-
43
- Rack::Auth::AbstractRequest::AUTHORIZATION_KEYS = T.let(T.unsafe(nil), Array)
44
-
45
- class Rack::Auth::Basic < ::Rack::Auth::AbstractHandler
46
- def call(env); end
47
-
48
- private
49
-
50
- def challenge; end
51
- def valid?(auth); end
52
- end
53
-
54
- class Rack::Auth::Basic::Request < ::Rack::Auth::AbstractRequest
55
- def basic?; end
56
- def credentials; end
57
- def username; end
58
- end
59
-
60
- module Rack::Auth::Digest; end
61
-
62
- class Rack::Auth::Digest::MD5 < ::Rack::Auth::AbstractHandler
63
- def initialize(app, realm = T.unsafe(nil), opaque = T.unsafe(nil), &authenticator); end
64
-
65
- def call(env); end
66
- def opaque; end
67
- def opaque=(_arg0); end
68
- def passwords_hashed=(_arg0); end
69
- def passwords_hashed?; end
70
-
71
- private
72
-
73
- def A1(auth, password); end
74
- def A2(auth); end
75
- def H(data); end
76
- def KD(secret, data); end
77
- def challenge(hash = T.unsafe(nil)); end
78
- def digest(auth, password); end
79
- def md5(data); end
80
- def params(hash = T.unsafe(nil)); end
81
- def valid?(auth); end
82
- def valid_digest?(auth); end
83
- def valid_nonce?(auth); end
84
- def valid_opaque?(auth); end
85
- def valid_qop?(auth); end
86
- end
87
-
88
- Rack::Auth::Digest::MD5::QOP = T.let(T.unsafe(nil), String)
89
-
90
- class Rack::Auth::Digest::Nonce
91
- def initialize(timestamp = T.unsafe(nil), given_digest = T.unsafe(nil)); end
92
-
93
- def digest; end
94
- def fresh?; end
95
- def stale?; end
96
- def to_s; end
97
- def valid?; end
98
-
99
- class << self
100
- def parse(string); end
101
- def private_key; end
102
- def private_key=(_arg0); end
103
- def time_limit; end
104
- def time_limit=(_arg0); end
105
- end
106
- end
107
-
108
- class Rack::Auth::Digest::Params < ::Hash
109
- def initialize; end
110
-
111
- def [](k); end
112
- def []=(k, v); end
113
- def quote(str); end
114
- def to_s; end
115
-
116
- class << self
117
- def dequote(str); end
118
- def parse(str); end
119
- def split_header_value(str); end
120
- end
121
- end
122
-
123
- Rack::Auth::Digest::Params::UNQUOTED = T.let(T.unsafe(nil), Array)
124
-
125
- class Rack::Auth::Digest::Request < ::Rack::Auth::AbstractRequest
126
- def correct_uri?; end
127
- def digest?; end
128
- def method; end
129
- def method_missing(sym, *args); end
130
- def nonce; end
131
- def params; end
132
- def respond_to?(sym, *_arg1); end
133
- end
134
-
135
- class Rack::BodyProxy
136
- def initialize(body, &block); end
137
-
138
- def close; end
139
- def closed?; end
140
- def method_missing(method_name, *args, &block); end
141
-
142
- private
143
-
144
- def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
145
- end
146
-
147
- class Rack::Builder
148
- def initialize(default_app = T.unsafe(nil), &block); end
149
-
150
- def call(env); end
151
- def freeze_app; end
152
- def map(path, &block); end
153
- def run(app); end
154
- def to_app; end
155
- def use(middleware, *args, &block); end
156
- def warmup(prc = T.unsafe(nil), &block); end
157
-
158
- private
159
-
160
- def generate_map(default_app, mapping); end
161
-
162
- class << self
163
- def app(default_app = T.unsafe(nil), &block); end
164
- def load_file(path, opts = T.unsafe(nil)); end
165
- def new_from_string(builder_script, file = T.unsafe(nil)); end
166
- def parse_file(config, opts = T.unsafe(nil)); end
167
- end
168
- end
169
-
170
- Rack::Builder::UTF_8_BOM = T.let(T.unsafe(nil), String)
171
- Rack::CACHE_CONTROL = T.let(T.unsafe(nil), String)
172
- Rack::CONTENT_LENGTH = T.let(T.unsafe(nil), String)
173
- Rack::CONTENT_TYPE = T.let(T.unsafe(nil), String)
174
-
175
- class Rack::Cascade
176
- def initialize(apps, cascade_for = T.unsafe(nil)); end
177
-
178
- def <<(app); end
179
- def add(app); end
180
- def apps; end
181
- def call(env); end
182
- def include?(app); end
183
- end
184
-
185
- Rack::Cascade::NotFound = T.let(T.unsafe(nil), Array)
186
-
187
- class Rack::Chunked
188
- include ::Rack::Utils
189
-
190
- def initialize(app); end
191
-
192
- def call(env); end
193
- def chunkable_version?(ver); end
194
- end
195
-
196
- class Rack::Chunked::Body
197
- def initialize(body); end
198
-
199
- def close; end
200
- def each(&block); end
201
-
202
- private
203
-
204
- def yield_trailers; end
205
- end
206
-
207
- Rack::Chunked::Body::TAIL = T.let(T.unsafe(nil), String)
208
- Rack::Chunked::Body::TERM = T.let(T.unsafe(nil), String)
209
-
210
- class Rack::Chunked::TrailerBody < ::Rack::Chunked::Body
211
- private
212
-
213
- def yield_trailers; end
214
- end
215
-
216
- class Rack::CommonLogger
217
- def initialize(app, logger = T.unsafe(nil)); end
218
-
219
- def call(env); end
220
-
221
- private
222
-
223
- def extract_content_length(headers); end
224
- def log(env, status, header, began_at); end
225
- end
226
-
227
- Rack::CommonLogger::FORMAT = T.let(T.unsafe(nil), String)
228
-
229
- class Rack::ConditionalGet
230
- def initialize(app); end
231
-
232
- def call(env); end
233
-
234
- private
235
-
236
- def etag_matches?(none_match, headers); end
237
- def fresh?(env, headers); end
238
- def modified_since?(modified_since, headers); end
239
- def to_rfc2822(since); end
240
- end
241
-
242
- class Rack::Config
243
- def initialize(app, &block); end
244
-
245
- def call(env); end
246
- end
247
-
248
- class Rack::ContentLength
249
- include ::Rack::Utils
250
-
251
- def initialize(app); end
252
-
253
- def call(env); end
254
- end
255
-
256
- class Rack::ContentType
257
- include ::Rack::Utils
258
-
259
- def initialize(app, content_type = T.unsafe(nil)); end
260
-
261
- def call(env); end
262
- end
263
-
264
- Rack::DELETE = T.let(T.unsafe(nil), String)
265
-
266
- class Rack::Deflater
267
- def initialize(app, options = T.unsafe(nil)); end
268
-
269
- def call(env); end
270
-
271
- private
272
-
273
- def should_deflate?(env, status, headers, body); end
274
- end
275
-
276
- class Rack::Deflater::GzipStream
277
- def initialize(body, mtime, sync); end
278
-
279
- def close; end
280
- def each(&block); end
281
- def write(data); end
282
- end
283
-
284
- class Rack::Directory
285
- def initialize(root, app = T.unsafe(nil)); end
286
-
287
- def call(env); end
288
- def check_bad_request(path_info); end
289
- def check_forbidden(path_info); end
290
- def entity_not_found(path_info); end
291
- def filesize_format(int); end
292
- def get(env); end
293
- def list_directory(path_info, path, script_name); end
294
- def list_path(env, path, path_info, script_name); end
295
- def root; end
296
- def stat(path); end
297
- end
298
-
299
- Rack::Directory::DIR_FILE = T.let(T.unsafe(nil), String)
300
- Rack::Directory::DIR_PAGE_FOOTER = T.let(T.unsafe(nil), String)
301
- Rack::Directory::DIR_PAGE_HEADER = T.let(T.unsafe(nil), String)
302
-
303
- class Rack::Directory::DirectoryBody < ::Struct
304
- def each; end
305
-
306
- private
307
-
308
- def DIR_FILE_escape(htmls); end
309
- end
310
-
311
- Rack::Directory::FILESIZE_FORMAT = T.let(T.unsafe(nil), Array)
312
- Rack::ETAG = T.let(T.unsafe(nil), String)
313
-
314
- class Rack::ETag
315
- def initialize(app, no_cache_control = T.unsafe(nil), cache_control = T.unsafe(nil)); end
316
-
317
- def call(env); end
318
-
319
- private
320
-
321
- def digest_body(body); end
322
- def etag_body?(body); end
323
- def etag_status?(status); end
324
- def skip_caching?(headers); end
325
- end
326
-
327
- Rack::ETag::DEFAULT_CACHE_CONTROL = T.let(T.unsafe(nil), String)
328
- Rack::ETag::ETAG_STRING = T.let(T.unsafe(nil), String)
329
- Rack::EXPIRES = T.let(T.unsafe(nil), String)
330
-
331
- class Rack::Events
332
- def initialize(app, handlers); end
333
-
334
- def call(env); end
335
-
336
- private
337
-
338
- def make_request(env); end
339
- def make_response(status, headers, body); end
340
- def on_commit(request, response); end
341
- def on_error(request, response, e); end
342
- def on_finish(request, response); end
343
- def on_start(request, response); end
344
- end
345
-
346
- module Rack::Events::Abstract
347
- def on_commit(req, res); end
348
- def on_error(req, res, e); end
349
- def on_finish(req, res); end
350
- def on_send(req, res); end
351
- def on_start(req, res); end
352
- end
353
-
354
- class Rack::Events::BufferedResponse < ::Rack::Response::Raw
355
- def initialize(status, headers, body); end
356
-
357
- def body; end
358
- def to_a; end
359
- end
360
-
361
- class Rack::Events::EventedBodyProxy < ::Rack::BodyProxy
362
- def initialize(body, request, response, handlers, &block); end
363
-
364
- def each; end
365
- def request; end
366
- def response; end
367
- end
368
-
369
- Rack::File = Rack::Files
370
-
371
- class Rack::Files
372
- def initialize(root, headers = T.unsafe(nil), default_mime = T.unsafe(nil)); end
373
-
374
- def call(env); end
375
- def get(env); end
376
- def root; end
377
- def serving(request, path); end
378
-
379
- private
380
-
381
- def fail(status, body, headers = T.unsafe(nil)); end
382
- def filesize(path); end
383
- def mime_type(path, default_mime); end
384
-
385
- class << self
386
- def method_added(name); end
387
- end
388
- end
389
-
390
- Rack::Files::ALLOWED_VERBS = T.let(T.unsafe(nil), Array)
391
- Rack::Files::ALLOW_HEADER = T.let(T.unsafe(nil), String)
392
-
393
- class Rack::Files::BaseIterator
394
- def initialize(path, ranges, options); end
395
-
396
- def bytesize; end
397
- def close; end
398
- def each; end
399
- def options; end
400
- def path; end
401
- def ranges; end
402
-
403
- private
404
-
405
- def each_range_part(file, range); end
406
- def multipart?; end
407
- def multipart_heading(range); end
408
- end
409
-
410
- class Rack::Files::Iterator < ::Rack::Files::BaseIterator
411
- def to_path; end
412
- end
413
-
414
- Rack::Files::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
415
-
416
- class Rack::ForwardRequest < ::Exception
417
- def initialize(url, env = T.unsafe(nil)); end
418
-
419
- def env; end
420
- def url; end
421
- end
422
-
423
- Rack::GET = T.let(T.unsafe(nil), String)
424
- Rack::HEAD = T.let(T.unsafe(nil), String)
425
- Rack::HTTPS = T.let(T.unsafe(nil), String)
426
- Rack::HTTP_COOKIE = T.let(T.unsafe(nil), String)
427
- Rack::HTTP_HOST = T.let(T.unsafe(nil), String)
428
- Rack::HTTP_PORT = T.let(T.unsafe(nil), String)
429
- Rack::HTTP_VERSION = T.let(T.unsafe(nil), String)
430
-
431
- module Rack::Handler
432
- class << self
433
- def default; end
434
- def get(server); end
435
- def pick(server_names); end
436
- def register(server, klass); end
437
- def try_require(prefix, const_name); end
438
- end
439
- end
440
-
441
- class Rack::Handler::CGI
442
- class << self
443
- def run(app, **options); end
444
- def send_body(body); end
445
- def send_headers(status, headers); end
446
- def serve(app); end
447
- end
448
- end
449
-
450
- Rack::Handler::SERVER_NAMES = T.let(T.unsafe(nil), Array)
451
-
452
- class Rack::Handler::WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
453
- def initialize(server, app); end
454
-
455
- def service(req, res); end
456
-
457
- class << self
458
- def run(app, **options); end
459
- def shutdown; end
460
- def valid_options; end
461
- end
462
- end
463
-
464
- class Rack::Head
465
- def initialize(app); end
466
-
467
- def call(env); end
468
- end
469
-
470
- Rack::LINK = T.let(T.unsafe(nil), String)
471
-
472
- class Rack::Lint
473
- include ::Rack::Lint::Assertion
474
-
475
- def initialize(app); end
476
-
477
- def _call(env); end
478
- def call(env = T.unsafe(nil)); end
479
- def check_content_length(status, headers); end
480
- def check_content_type(status, headers); end
481
- def check_env(env); end
482
- def check_error(error); end
483
- def check_headers(header); end
484
- def check_hijack(env); end
485
- def check_hijack_response(headers, env); end
486
- def check_input(input); end
487
- def check_status(status); end
488
- def close; end
489
- def each; end
490
- def verify_content_length(bytes); end
491
- end
492
-
493
- module Rack::Lint::Assertion
494
- def assert(message); end
495
- end
496
-
497
- class Rack::Lint::ErrorWrapper
498
- include ::Rack::Lint::Assertion
499
-
500
- def initialize(error); end
501
-
502
- def close(*args); end
503
- def flush; end
504
- def puts(str); end
505
- def write(str); end
506
- end
507
-
508
- class Rack::Lint::HijackWrapper
509
- include ::Rack::Lint::Assertion
510
- extend ::Forwardable
511
-
512
- def initialize(io); end
513
-
514
- def close(*args, &block); end
515
- def close_read(*args, &block); end
516
- def close_write(*args, &block); end
517
- def closed?(*args, &block); end
518
- def flush(*args, &block); end
519
- def read(*args, &block); end
520
- def read_nonblock(*args, &block); end
521
- def write(*args, &block); end
522
- def write_nonblock(*args, &block); end
523
- end
524
-
525
- Rack::Lint::HijackWrapper::REQUIRED_METHODS = T.let(T.unsafe(nil), Array)
526
-
527
- class Rack::Lint::InputWrapper
528
- include ::Rack::Lint::Assertion
529
-
530
- def initialize(input); end
531
-
532
- def close(*args); end
533
- def each(*args); end
534
- def gets(*args); end
535
- def read(*args); end
536
- def rewind(*args); end
537
- end
538
-
539
- class Rack::Lint::LintError < ::RuntimeError; end
540
-
541
- class Rack::Lock
542
- def initialize(app, mutex = T.unsafe(nil)); end
543
-
544
- def call(env); end
545
-
546
- private
547
-
548
- def unlock; end
549
- end
550
-
551
- class Rack::Logger
552
- def initialize(app, level = T.unsafe(nil)); end
553
-
554
- def call(env); end
555
- end
556
-
557
- class Rack::MediaType
558
- class << self
559
- def params(content_type); end
560
- def type(content_type); end
561
-
562
- private
563
-
564
- def strip_doublequotes(str); end
565
- end
566
- end
567
-
568
- Rack::MediaType::SPLIT_PATTERN = T.let(T.unsafe(nil), Regexp)
569
-
570
- class Rack::MethodOverride
571
- def initialize(app); end
572
-
573
- def call(env); end
574
- def method_override(env); end
575
-
576
- private
577
-
578
- def allowed_methods; end
579
- def method_override_param(req); end
580
- end
581
-
582
- Rack::MethodOverride::ALLOWED_METHODS = T.let(T.unsafe(nil), Array)
583
- Rack::MethodOverride::HTTP_METHODS = T.let(T.unsafe(nil), Array)
584
- Rack::MethodOverride::HTTP_METHOD_OVERRIDE_HEADER = T.let(T.unsafe(nil), String)
585
- Rack::MethodOverride::METHOD_OVERRIDE_PARAM_KEY = T.let(T.unsafe(nil), String)
586
-
587
- module Rack::Mime
588
- private
589
-
590
- def match?(value, matcher); end
591
- def mime_type(ext, fallback = T.unsafe(nil)); end
592
-
593
- class << self
594
- def match?(value, matcher); end
595
- def mime_type(ext, fallback = T.unsafe(nil)); end
596
- end
597
- end
598
-
599
- Rack::Mime::MIME_TYPES = T.let(T.unsafe(nil), Hash)
600
-
601
- class Rack::MockRequest
602
- def initialize(app); end
603
-
604
- def delete(uri, opts = T.unsafe(nil)); end
605
- def get(uri, opts = T.unsafe(nil)); end
606
- def head(uri, opts = T.unsafe(nil)); end
607
- def options(uri, opts = T.unsafe(nil)); end
608
- def patch(uri, opts = T.unsafe(nil)); end
609
- def post(uri, opts = T.unsafe(nil)); end
610
- def put(uri, opts = T.unsafe(nil)); end
611
- def request(method = T.unsafe(nil), uri = T.unsafe(nil), opts = T.unsafe(nil)); end
612
-
613
- class << self
614
- def env_for(uri = T.unsafe(nil), opts = T.unsafe(nil)); end
615
- def parse_uri_rfc2396(uri); end
616
- end
617
- end
618
-
619
- Rack::MockRequest::DEFAULT_ENV = T.let(T.unsafe(nil), Hash)
620
-
621
- class Rack::MockRequest::FatalWarner
622
- def flush; end
623
- def puts(warning); end
624
- def string; end
625
- def write(warning); end
626
- end
627
-
628
- class Rack::MockRequest::FatalWarning < ::RuntimeError; end
629
-
630
- class Rack::MockResponse < ::Rack::Response
631
- def initialize(status, headers, body, errors = T.unsafe(nil)); end
632
-
633
- def =~(other); end
634
- def body; end
635
- def cookie(name); end
636
- def cookies; end
637
- def empty?; end
638
- def errors; end
639
- def errors=(_arg0); end
640
- def match(other); end
641
- def original_headers; end
642
-
643
- private
644
-
645
- def identify_cookie_attributes(cookie_filling); end
646
- def parse_cookies_from_header; end
647
-
648
- class << self
649
- def [](*_arg0); end
650
- end
651
- end
652
-
653
- module Rack::Multipart
654
- class << self
655
- def build_multipart(params, first = T.unsafe(nil)); end
656
- def extract_multipart(req, params = T.unsafe(nil)); end
657
- def parse_multipart(env, params = T.unsafe(nil)); end
658
- end
659
- end
660
-
661
- Rack::Multipart::ATTRIBUTE = T.let(T.unsafe(nil), Regexp)
662
- Rack::Multipart::ATTRIBUTE_CHAR = T.let(T.unsafe(nil), Regexp)
663
- Rack::Multipart::BROKEN_QUOTED = T.let(T.unsafe(nil), Regexp)
664
- Rack::Multipart::BROKEN_UNQUOTED = T.let(T.unsafe(nil), Regexp)
665
- Rack::Multipart::CONDISP = T.let(T.unsafe(nil), Regexp)
666
- Rack::Multipart::DISPPARM = T.let(T.unsafe(nil), Regexp)
667
- Rack::Multipart::EOL = T.let(T.unsafe(nil), String)
668
- Rack::Multipart::EXTENDED_INITIAL_NAME = T.let(T.unsafe(nil), Regexp)
669
- Rack::Multipart::EXTENDED_INITIAL_PARAMETER = T.let(T.unsafe(nil), Regexp)
670
- Rack::Multipart::EXTENDED_INITIAL_VALUE = T.let(T.unsafe(nil), Regexp)
671
- Rack::Multipart::EXTENDED_OTHER_NAME = T.let(T.unsafe(nil), Regexp)
672
- Rack::Multipart::EXTENDED_OTHER_PARAMETER = T.let(T.unsafe(nil), Regexp)
673
- Rack::Multipart::EXTENDED_OTHER_VALUE = T.let(T.unsafe(nil), Regexp)
674
- Rack::Multipart::EXTENDED_PARAMETER = T.let(T.unsafe(nil), Regexp)
675
-
676
- class Rack::Multipart::Generator
677
- def initialize(params, first = T.unsafe(nil)); end
678
-
679
- def dump; end
680
-
681
- private
682
-
683
- def content_for_other(file, name); end
684
- def content_for_tempfile(io, file, name); end
685
- def flattened_params; end
686
- def multipart?; end
687
- end
688
-
689
- Rack::Multipart::MULTIPART = T.let(T.unsafe(nil), Regexp)
690
- Rack::Multipart::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
691
- Rack::Multipart::MULTIPART_CONTENT_DISPOSITION = T.let(T.unsafe(nil), Regexp)
692
- Rack::Multipart::MULTIPART_CONTENT_ID = T.let(T.unsafe(nil), Regexp)
693
- Rack::Multipart::MULTIPART_CONTENT_TYPE = T.let(T.unsafe(nil), Regexp)
694
- class Rack::Multipart::MultipartPartLimitError < ::Errno::EMFILE; end
695
-
696
- class Rack::Multipart::Parser
697
- def initialize(boundary, tempfile, bufsize, query_parser); end
698
-
699
- def on_read(content); end
700
- def result; end
701
- def state; end
702
-
703
- private
704
-
705
- def consume_boundary; end
706
- def full_boundary; end
707
- def get_filename(head); end
708
- def handle_consume_token; end
709
- def handle_empty_content!(content); end
710
- def handle_fast_forward; end
711
- def handle_mime_body; end
712
- def handle_mime_head; end
713
- def run_parser; end
714
- def tag_multipart_encoding(filename, content_type, name, body); end
715
-
716
- class << self
717
- def parse(io, content_length, content_type, tmpfile, bufsize, qp); end
718
- def parse_boundary(content_type); end
719
- end
720
- end
721
-
722
- Rack::Multipart::Parser::BOUNDARY_REGEX = T.let(T.unsafe(nil), Regexp)
723
- Rack::Multipart::Parser::BUFSIZE = T.let(T.unsafe(nil), Integer)
724
-
725
- class Rack::Multipart::Parser::BoundedIO
726
- def initialize(io, content_length); end
727
-
728
- def read(size, outbuf = T.unsafe(nil)); end
729
- def rewind; end
730
- end
731
-
732
- Rack::Multipart::Parser::CHARSET = T.let(T.unsafe(nil), String)
733
-
734
- class Rack::Multipart::Parser::Collector
735
- include ::Enumerable
736
-
737
- def initialize(tempfile); end
738
-
739
- def each; end
740
- def on_mime_body(mime_index, content); end
741
- def on_mime_finish(mime_index); end
742
- def on_mime_head(mime_index, head, filename, content_type, name); end
743
-
744
- private
745
-
746
- def check_open_files; end
747
- end
748
-
749
- class Rack::Multipart::Parser::Collector::BufferPart < ::Rack::Multipart::Parser::Collector::MimePart
750
- def close; end
751
- def file?; end
752
- end
753
-
754
- class Rack::Multipart::Parser::Collector::MimePart < ::Struct
755
- def get_data; end
756
- end
757
-
758
- class Rack::Multipart::Parser::Collector::TempfilePart < ::Rack::Multipart::Parser::Collector::MimePart
759
- def close; end
760
- def file?; end
761
- end
762
-
763
- Rack::Multipart::Parser::EMPTY = T.let(T.unsafe(nil), Rack::Multipart::Parser::MultipartInfo)
764
-
765
- class Rack::Multipart::Parser::MultipartInfo < ::Struct
766
- def params; end
767
- def params=(_); end
768
- def tmp_files; end
769
- def tmp_files=(_); end
770
-
771
- class << self
772
- def [](*_arg0); end
773
- def inspect; end
774
- def members; end
775
- def new(*_arg0); end
776
- end
777
- end
778
-
779
- Rack::Multipart::Parser::TEMPFILE_FACTORY = T.let(T.unsafe(nil), Proc)
780
- Rack::Multipart::Parser::TEXT_PLAIN = T.let(T.unsafe(nil), String)
781
- Rack::Multipart::REGULAR_PARAMETER = T.let(T.unsafe(nil), Regexp)
782
- Rack::Multipart::REGULAR_PARAMETER_NAME = T.let(T.unsafe(nil), Regexp)
783
- Rack::Multipart::RFC2183 = T.let(T.unsafe(nil), Regexp)
784
- Rack::Multipart::SECTION = T.let(T.unsafe(nil), Regexp)
785
- Rack::Multipart::TOKEN = T.let(T.unsafe(nil), Regexp)
786
-
787
- class Rack::Multipart::UploadedFile
788
- def initialize(filepath = T.unsafe(nil), ct = T.unsafe(nil), bin = T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end
789
-
790
- def content_type; end
791
- def content_type=(_arg0); end
792
- def local_path; end
793
- def method_missing(method_name, *args, &block); end
794
- def original_filename; end
795
- def path; end
796
- def respond_to?(*args); end
797
- end
798
-
799
- Rack::Multipart::VALUE = T.let(T.unsafe(nil), Regexp)
800
-
801
- class Rack::NullLogger
802
- def initialize(app); end
803
-
804
- def <<(msg); end
805
- def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
806
- def call(env); end
807
- def close; end
808
- def datetime_format; end
809
- def datetime_format=(datetime_format); end
810
- def debug(progname = T.unsafe(nil), &block); end
811
- def debug?; end
812
- def error(progname = T.unsafe(nil), &block); end
813
- def error?; end
814
- def fatal(progname = T.unsafe(nil), &block); end
815
- def fatal?; end
816
- def formatter; end
817
- def formatter=(formatter); end
818
- def info(progname = T.unsafe(nil), &block); end
819
- def info?; end
820
- def level; end
821
- def level=(level); end
822
- def progname; end
823
- def progname=(progname); end
824
- def sev_threshold; end
825
- def sev_threshold=(sev_threshold); end
826
- def unknown(progname = T.unsafe(nil), &block); end
827
- def warn(progname = T.unsafe(nil), &block); end
828
- def warn?; end
829
- end
830
-
831
- Rack::OPTIONS = T.let(T.unsafe(nil), String)
832
- Rack::PATCH = T.let(T.unsafe(nil), String)
833
- Rack::PATH_INFO = T.let(T.unsafe(nil), String)
834
- Rack::POST = T.let(T.unsafe(nil), String)
835
- Rack::PUT = T.let(T.unsafe(nil), String)
836
- Rack::QUERY_STRING = T.let(T.unsafe(nil), String)
837
-
838
- class Rack::QueryParser
839
- def initialize(params_class, key_space_limit, param_depth_limit); end
840
-
841
- def key_space_limit; end
842
- def make_params; end
843
- def new_depth_limit(param_depth_limit); end
844
- def new_space_limit(key_space_limit); end
845
- def normalize_params(params, name, v, depth); end
846
- def param_depth_limit; end
847
- def parse_nested_query(qs, d = T.unsafe(nil)); end
848
- def parse_query(qs, d = T.unsafe(nil), &unescaper); end
849
-
850
- private
851
-
852
- def params_hash_has_key?(hash, key); end
853
- def params_hash_type?(obj); end
854
- def unescape(s); end
855
-
856
- class << self
857
- def make_default(key_space_limit, param_depth_limit); end
858
- end
859
- end
860
-
861
- Rack::QueryParser::COMMON_SEP = T.let(T.unsafe(nil), Hash)
862
- Rack::QueryParser::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
863
- class Rack::QueryParser::InvalidParameterError < ::ArgumentError; end
864
- class Rack::QueryParser::ParameterTypeError < ::TypeError; end
865
-
866
- class Rack::QueryParser::Params
867
- def initialize(limit); end
868
-
869
- def [](key); end
870
- def []=(key, value); end
871
- def key?(key); end
872
- def to_h; end
873
- def to_params_hash; end
874
- end
875
-
876
- Rack::RACK_ERRORS = T.let(T.unsafe(nil), String)
877
- Rack::RACK_HIJACK = T.let(T.unsafe(nil), String)
878
- Rack::RACK_HIJACK_IO = T.let(T.unsafe(nil), String)
879
- Rack::RACK_INPUT = T.let(T.unsafe(nil), String)
880
- Rack::RACK_IS_HIJACK = T.let(T.unsafe(nil), String)
881
- Rack::RACK_LOGGER = T.let(T.unsafe(nil), String)
882
- Rack::RACK_METHODOVERRIDE_ORIGINAL_METHOD = T.let(T.unsafe(nil), String)
883
- Rack::RACK_MULTIPART_BUFFER_SIZE = T.let(T.unsafe(nil), String)
884
- Rack::RACK_MULTIPART_TEMPFILE_FACTORY = T.let(T.unsafe(nil), String)
885
- Rack::RACK_MULTIPROCESS = T.let(T.unsafe(nil), String)
886
- Rack::RACK_MULTITHREAD = T.let(T.unsafe(nil), String)
887
- Rack::RACK_RECURSIVE_INCLUDE = T.let(T.unsafe(nil), String)
888
- Rack::RACK_REQUEST_COOKIE_HASH = T.let(T.unsafe(nil), String)
889
- Rack::RACK_REQUEST_COOKIE_STRING = T.let(T.unsafe(nil), String)
890
- Rack::RACK_REQUEST_FORM_HASH = T.let(T.unsafe(nil), String)
891
- Rack::RACK_REQUEST_FORM_INPUT = T.let(T.unsafe(nil), String)
892
- Rack::RACK_REQUEST_FORM_VARS = T.let(T.unsafe(nil), String)
893
- Rack::RACK_REQUEST_QUERY_HASH = T.let(T.unsafe(nil), String)
894
- Rack::RACK_REQUEST_QUERY_STRING = T.let(T.unsafe(nil), String)
895
- Rack::RACK_RUNONCE = T.let(T.unsafe(nil), String)
896
- Rack::RACK_SESSION = T.let(T.unsafe(nil), String)
897
- Rack::RACK_SESSION_OPTIONS = T.let(T.unsafe(nil), String)
898
- Rack::RACK_SESSION_UNPACKED_COOKIE_DATA = T.let(T.unsafe(nil), String)
899
- Rack::RACK_SHOWSTATUS_DETAIL = T.let(T.unsafe(nil), String)
900
- Rack::RACK_TEMPFILES = T.let(T.unsafe(nil), String)
901
- Rack::RACK_URL_SCHEME = T.let(T.unsafe(nil), String)
902
- Rack::RACK_VERSION = T.let(T.unsafe(nil), String)
903
- Rack::RELEASE = T.let(T.unsafe(nil), String)
904
- Rack::REQUEST_METHOD = T.let(T.unsafe(nil), String)
905
- Rack::REQUEST_PATH = T.let(T.unsafe(nil), String)
906
-
907
- class Rack::Recursive
908
- def initialize(app); end
909
-
910
- def _call(env); end
911
- def call(env); end
912
- def include(env, path); end
913
- end
914
-
915
- class Rack::Reloader
916
- def initialize(app, cooldown = T.unsafe(nil), backend = T.unsafe(nil)); end
917
-
918
- def call(env); end
919
- def reload!(stderr = T.unsafe(nil)); end
920
- def safe_load(file, mtime, stderr = T.unsafe(nil)); end
921
- end
922
-
923
- module Rack::Reloader::Stat
924
- def figure_path(file, paths); end
925
- def rotation; end
926
- def safe_stat(file); end
927
- end
928
-
929
- class Rack::Request
930
- include ::Rack::Request::Env
931
- include ::Rack::Request::Helpers
932
-
933
- def initialize(env); end
934
-
935
- def delete_param(k); end
936
- def params; end
937
- def update_param(k, v); end
938
-
939
- class << self
940
- def ip_filter; end
941
- def ip_filter=(_arg0); end
942
- end
943
- end
944
-
945
- Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array)
946
-
947
- module Rack::Request::Env
948
- def initialize(env); end
949
-
950
- def add_header(key, v); end
951
- def delete_header(name); end
952
- def each_header(&block); end
953
- def env; end
954
- def fetch_header(name, &block); end
955
- def get_header(name); end
956
- def has_header?(name); end
957
- def set_header(name, v); end
958
-
959
- private
960
-
961
- def initialize_copy(other); end
962
- end
963
-
964
- module Rack::Request::Helpers
965
- def GET; end
966
- def POST; end
967
- def [](key); end
968
- def []=(key, value); end
969
- def accept_encoding; end
970
- def accept_language; end
971
- def authority; end
972
- def base_url; end
973
- def body; end
974
- def content_charset; end
975
- def content_length; end
976
- def content_type; end
977
- def cookies; end
978
- def delete?; end
979
- def delete_param(k); end
980
- def form_data?; end
981
- def forwarded_authority; end
982
- def forwarded_for; end
983
- def forwarded_port; end
984
- def fullpath; end
985
- def get?; end
986
- def head?; end
987
- def host; end
988
- def host_authority; end
989
- def host_with_port(authority = T.unsafe(nil)); end
990
- def hostname; end
991
- def ip; end
992
- def link?; end
993
- def logger; end
994
- def media_type; end
995
- def media_type_params; end
996
- def multithread?; end
997
- def options?; end
998
- def params; end
999
- def parseable_data?; end
1000
- def patch?; end
1001
- def path; end
1002
- def path_info; end
1003
- def path_info=(s); end
1004
- def port; end
1005
- def post?; end
1006
- def put?; end
1007
- def query_string; end
1008
- def referer; end
1009
- def referrer; end
1010
- def request_method; end
1011
- def scheme; end
1012
- def script_name; end
1013
- def script_name=(s); end
1014
- def server_authority; end
1015
- def server_name; end
1016
- def server_port; end
1017
- def session; end
1018
- def session_options; end
1019
- def ssl?; end
1020
- def trace?; end
1021
- def trusted_proxy?(ip); end
1022
- def unlink?; end
1023
- def update_param(k, v); end
1024
- def url; end
1025
- def user_agent; end
1026
- def values_at(*keys); end
1027
- def xhr?; end
1028
-
1029
- private
1030
-
1031
- def allowed_scheme(header); end
1032
- def default_session; end
1033
- def extract_proto_header(header); end
1034
- def forwarded_scheme; end
1035
- def parse_http_accept_header(header); end
1036
- def parse_multipart; end
1037
- def parse_query(qs, d = T.unsafe(nil)); end
1038
- def query_parser; end
1039
- def reject_trusted_ip_addresses(ip_addresses); end
1040
- def split_authority(authority); end
1041
- def split_header(value); end
1042
- def wrap_ipv6(host); end
1043
- end
1044
-
1045
- Rack::Request::Helpers::AUTHORITY = T.let(T.unsafe(nil), Regexp)
1046
- Rack::Request::Helpers::DEFAULT_PORTS = T.let(T.unsafe(nil), Hash)
1047
- Rack::Request::Helpers::FORM_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
1048
- Rack::Request::Helpers::HTTP_X_FORWARDED_FOR = T.let(T.unsafe(nil), String)
1049
- Rack::Request::Helpers::HTTP_X_FORWARDED_HOST = T.let(T.unsafe(nil), String)
1050
- Rack::Request::Helpers::HTTP_X_FORWARDED_PORT = T.let(T.unsafe(nil), String)
1051
- Rack::Request::Helpers::HTTP_X_FORWARDED_PROTO = T.let(T.unsafe(nil), String)
1052
- Rack::Request::Helpers::HTTP_X_FORWARDED_SCHEME = T.let(T.unsafe(nil), String)
1053
- Rack::Request::Helpers::HTTP_X_FORWARDED_SSL = T.let(T.unsafe(nil), String)
1054
- Rack::Request::Helpers::PARSEABLE_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
1055
- Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array)
1056
-
1057
- class Rack::Response
1058
- include ::Rack::Response::Helpers
1059
-
1060
- def initialize(body = T.unsafe(nil), status = T.unsafe(nil), headers = T.unsafe(nil)); end
1061
-
1062
- def [](key); end
1063
- def []=(key, v); end
1064
- def body; end
1065
- def body=(_arg0); end
1066
- def chunked?; end
1067
- def close; end
1068
- def delete_header(key); end
1069
- def each(&callback); end
1070
- def empty?; end
1071
- def finish(&block); end
1072
- def get_header(key); end
1073
- def has_header?(key); end
1074
- def header; end
1075
- def headers; end
1076
- def length; end
1077
- def length=(_arg0); end
1078
- def redirect(target, status = T.unsafe(nil)); end
1079
- def set_header(key, v); end
1080
- def status; end
1081
- def status=(_arg0); end
1082
- def to_a(&block); end
1083
- def write(chunk); end
1084
-
1085
- class << self
1086
- def [](status, headers, body); end
1087
- end
1088
- end
1089
-
1090
- Rack::Response::CHUNKED = T.let(T.unsafe(nil), String)
1091
-
1092
- module Rack::Response::Helpers
1093
- def accepted?; end
1094
- def add_header(key, v); end
1095
- def bad_request?; end
1096
- def cache!(duration = T.unsafe(nil), directive: T.unsafe(nil)); end
1097
- def cache_control; end
1098
- def cache_control=(v); end
1099
- def client_error?; end
1100
- def content_length; end
1101
- def content_type; end
1102
- def content_type=(content_type); end
1103
- def created?; end
1104
- def delete_cookie(key, value = T.unsafe(nil)); end
1105
- def do_not_cache!; end
1106
- def etag; end
1107
- def etag=(v); end
1108
- def forbidden?; end
1109
- def include?(header); end
1110
- def informational?; end
1111
- def invalid?; end
1112
- def location; end
1113
- def location=(location); end
1114
- def media_type; end
1115
- def media_type_params; end
1116
- def method_not_allowed?; end
1117
- def moved_permanently?; end
1118
- def no_content?; end
1119
- def not_found?; end
1120
- def ok?; end
1121
- def precondition_failed?; end
1122
- def redirect?; end
1123
- def redirection?; end
1124
- def server_error?; end
1125
- def set_cookie(key, value); end
1126
- def set_cookie_header; end
1127
- def set_cookie_header=(v); end
1128
- def successful?; end
1129
- def unauthorized?; end
1130
- def unprocessable?; end
1131
-
1132
- protected
1133
-
1134
- def append(chunk); end
1135
- def buffered_body!; end
1136
- end
1137
-
1138
- class Rack::Response::Raw
1139
- include ::Rack::Response::Helpers
1140
-
1141
- def initialize(status, headers); end
1142
-
1143
- def delete_header(key); end
1144
- def get_header(key); end
1145
- def has_header?(key); end
1146
- def headers; end
1147
- def set_header(key, v); end
1148
- def status; end
1149
- def status=(_arg0); end
1150
- end
1151
-
1152
- Rack::Response::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
1153
-
1154
- class Rack::RewindableInput
1155
- def initialize(io); end
1156
-
1157
- def close; end
1158
- def each(&block); end
1159
- def gets; end
1160
- def read(*args); end
1161
- def rewind; end
1162
-
1163
- private
1164
-
1165
- def filesystem_has_posix_semantics?; end
1166
- def make_rewindable; end
1167
- end
1168
-
1169
- class Rack::Runtime
1170
- def initialize(app, name = T.unsafe(nil)); end
1171
-
1172
- def call(env); end
1173
- end
1174
-
1175
- Rack::Runtime::FORMAT_STRING = T.let(T.unsafe(nil), String)
1176
- Rack::Runtime::HEADER_NAME = T.let(T.unsafe(nil), String)
1177
- Rack::SCRIPT_NAME = T.let(T.unsafe(nil), String)
1178
- Rack::SERVER_NAME = T.let(T.unsafe(nil), String)
1179
- Rack::SERVER_PORT = T.let(T.unsafe(nil), String)
1180
- Rack::SERVER_PROTOCOL = T.let(T.unsafe(nil), String)
1181
- Rack::SET_COOKIE = T.let(T.unsafe(nil), String)
1182
-
1183
- class Rack::Sendfile
1184
- def initialize(app, variation = T.unsafe(nil), mappings = T.unsafe(nil)); end
1185
-
1186
- def call(env); end
1187
-
1188
- private
1189
-
1190
- def map_accel_path(env, path); end
1191
- def variation(env); end
1192
- end
1193
-
1194
- class Rack::Server
1195
- def initialize(options = T.unsafe(nil)); end
1196
-
1197
- def app; end
1198
- def default_options; end
1199
- def middleware; end
1200
- def options; end
1201
- def options=(_arg0); end
1202
- def server; end
1203
- def start(&block); end
1204
-
1205
- private
1206
-
1207
- def build_app(app); end
1208
- def build_app_and_options_from_config; end
1209
- def build_app_from_string; end
1210
- def check_pid!; end
1211
- def daemonize_app; end
1212
- def handle_profiling(heapfile, profile_mode, filename); end
1213
- def make_profile_name(filename); end
1214
- def opt_parser; end
1215
- def parse_options(args); end
1216
- def pidfile_process_status; end
1217
- def wrapped_app; end
1218
- def write_pid; end
1219
-
1220
- class << self
1221
- def default_middleware_by_environment; end
1222
- def logging_middleware; end
1223
- def middleware; end
1224
- def start(options = T.unsafe(nil)); end
1225
- end
1226
- end
1227
-
1228
- class Rack::Server::Options
1229
- def handler_opts(options); end
1230
- def parse!(args); end
1231
- end
1232
-
1233
- module Rack::Session; end
1234
- module Rack::Session::Abstract; end
1235
-
1236
- class Rack::Session::Abstract::ID < ::Rack::Session::Abstract::Persisted
1237
- def delete_session(req, sid, options); end
1238
- def find_session(req, sid); end
1239
- def write_session(req, sid, session, options); end
1240
-
1241
- class << self
1242
- def inherited(klass); end
1243
- end
1244
- end
1245
-
1246
- class Rack::Session::Abstract::Persisted
1247
- def initialize(app, options = T.unsafe(nil)); end
1248
-
1249
- def call(env); end
1250
- def commit_session(req, res); end
1251
- def context(env, app = T.unsafe(nil)); end
1252
- def default_options; end
1253
- def key; end
1254
- def sid_secure; end
1255
-
1256
- private
1257
-
1258
- def commit_session?(req, session, options); end
1259
- def cookie_value(data); end
1260
- def current_session_id(req); end
1261
- def delete_session(req, sid, options); end
1262
- def extract_session_id(request); end
1263
- def find_session(env, sid); end
1264
- def force_options?(options); end
1265
- def forced_session_update?(session, options); end
1266
- def generate_sid(secure = T.unsafe(nil)); end
1267
- def initialize_sid; end
1268
- def load_session(req); end
1269
- def loaded_session?(session); end
1270
- def make_request(env); end
1271
- def prepare_session(req); end
1272
- def security_matches?(request, options); end
1273
- def session_class; end
1274
- def session_exists?(req); end
1275
- def set_cookie(request, res, cookie); end
1276
- def write_session(req, sid, session, options); end
1277
- end
1278
-
1279
- Rack::Session::Abstract::Persisted::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
1280
-
1281
- class Rack::Session::Abstract::PersistedSecure < ::Rack::Session::Abstract::Persisted
1282
- def extract_session_id(*_arg0); end
1283
- def generate_sid(*_arg0); end
1284
-
1285
- private
1286
-
1287
- def cookie_value(data); end
1288
- def session_class; end
1289
- end
1290
-
1291
- class Rack::Session::Abstract::PersistedSecure::SecureSessionHash < ::Rack::Session::Abstract::SessionHash
1292
- def [](key); end
1293
- end
1294
-
1295
- class Rack::Session::Abstract::SessionHash
1296
- include ::Enumerable
1297
-
1298
- def initialize(store, req); end
1299
-
1300
- def [](key); end
1301
- def []=(key, value); end
1302
- def clear; end
1303
- def delete(key); end
1304
- def destroy; end
1305
- def dig(key, *keys); end
1306
- def each(&block); end
1307
- def empty?; end
1308
- def exists?; end
1309
- def fetch(key, default = T.unsafe(nil), &block); end
1310
- def has_key?(key); end
1311
- def id; end
1312
- def id=(_arg0); end
1313
- def include?(key); end
1314
- def inspect; end
1315
- def key?(key); end
1316
- def keys; end
1317
- def loaded?; end
1318
- def merge!(hash); end
1319
- def options; end
1320
- def replace(hash); end
1321
- def store(key, value); end
1322
- def to_hash; end
1323
- def update(hash); end
1324
- def values; end
1325
-
1326
- private
1327
-
1328
- def load!; end
1329
- def load_for_read!; end
1330
- def load_for_write!; end
1331
- def stringify_keys(other); end
1332
-
1333
- class << self
1334
- def find(req); end
1335
- def set(req, session); end
1336
- def set_options(req, options); end
1337
- end
1338
- end
1339
-
1340
- Rack::Session::Abstract::SessionHash::Unspecified = T.let(T.unsafe(nil), Object)
1341
-
1342
- class Rack::Session::Cookie < ::Rack::Session::Abstract::PersistedSecure
1343
- def initialize(app, options = T.unsafe(nil)); end
1344
-
1345
- def coder; end
1346
-
1347
- private
1348
-
1349
- def delete_session(req, session_id, options); end
1350
- def digest_match?(data, digest); end
1351
- def extract_session_id(request); end
1352
- def find_session(req, sid); end
1353
- def generate_hmac(data, secret); end
1354
- def persistent_session_id!(data, sid = T.unsafe(nil)); end
1355
- def secure?(options); end
1356
- def unpacked_cookie_data(request); end
1357
- def write_session(req, session_id, session, options); end
1358
- end
1359
-
1360
- class Rack::Session::Cookie::Base64
1361
- def decode(str); end
1362
- def encode(str); end
1363
- end
1364
-
1365
- class Rack::Session::Cookie::Base64::JSON < ::Rack::Session::Cookie::Base64
1366
- def decode(str); end
1367
- def encode(obj); end
1368
- end
1369
-
1370
- class Rack::Session::Cookie::Base64::Marshal < ::Rack::Session::Cookie::Base64
1371
- def decode(str); end
1372
- def encode(str); end
1373
- end
1374
-
1375
- class Rack::Session::Cookie::Base64::ZipJSON < ::Rack::Session::Cookie::Base64
1376
- def decode(str); end
1377
- def encode(obj); end
1378
- end
1379
-
1380
- class Rack::Session::Cookie::Identity
1381
- def decode(str); end
1382
- def encode(str); end
1383
- end
1384
-
1385
- class Rack::Session::Cookie::SessionId
1386
- def initialize(session_id, cookie_value); end
1387
-
1388
- def cookie_value; end
1389
- end
1390
-
1391
- class Rack::Session::Pool < ::Rack::Session::Abstract::PersistedSecure
1392
- def initialize(app, options = T.unsafe(nil)); end
1393
-
1394
- def delete_session(req, session_id, options); end
1395
- def find_session(req, sid); end
1396
- def generate_sid; end
1397
- def mutex; end
1398
- def pool; end
1399
- def with_lock(req); end
1400
- def write_session(req, session_id, new_session, options); end
1401
-
1402
- private
1403
-
1404
- def get_session_with_fallback(sid); end
1405
- end
1406
-
1407
- Rack::Session::Pool::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
1408
-
1409
- class Rack::Session::SessionId
1410
- def initialize(public_id); end
1411
-
1412
- def cookie_value; end
1413
- def empty?; end
1414
- def inspect; end
1415
- def private_id; end
1416
- def public_id; end
1417
- def to_s; end
1418
-
1419
- private
1420
-
1421
- def hash_sid(sid); end
1422
- end
1423
-
1424
- Rack::Session::SessionId::ID_VERSION = T.let(T.unsafe(nil), Integer)
1425
-
1426
- class Rack::ShowExceptions
1427
- def initialize(app); end
1428
-
1429
- def call(env); end
1430
- def dump_exception(exception); end
1431
- def h(obj); end
1432
- def prefers_plaintext?(env); end
1433
- def pretty(env, exception); end
1434
- def template; end
1435
-
1436
- private
1437
-
1438
- def accepts_html?(env); end
1439
- end
1440
-
1441
- Rack::ShowExceptions::CONTEXT = T.let(T.unsafe(nil), Integer)
1442
- Rack::ShowExceptions::TEMPLATE = T.let(T.unsafe(nil), ERB)
1443
-
1444
- class Rack::ShowStatus
1445
- def initialize(app); end
1446
-
1447
- def call(env); end
1448
- def h(obj); end
1449
- end
1450
-
1451
- Rack::ShowStatus::TEMPLATE = T.let(T.unsafe(nil), String)
1452
-
1453
- class Rack::Static
1454
- def initialize(app, options = T.unsafe(nil)); end
1455
-
1456
- def add_index_root?(path); end
1457
- def applicable_rules(path); end
1458
- def call(env); end
1459
- def can_serve(path); end
1460
- def overwrite_file_path(path); end
1461
- def route_file(path); end
1462
- end
1463
-
1464
- Rack::TRACE = T.let(T.unsafe(nil), String)
1465
- Rack::TRANSFER_ENCODING = T.let(T.unsafe(nil), String)
1466
-
1467
- class Rack::TempfileReaper
1468
- def initialize(app); end
1469
-
1470
- def call(env); end
1471
- end
1472
-
1473
- Rack::UNLINK = T.let(T.unsafe(nil), String)
1474
-
1475
- class Rack::URLMap
1476
- def initialize(map = T.unsafe(nil)); end
1477
-
1478
- def call(env); end
1479
- def remap(map); end
1480
-
1481
- private
1482
-
1483
- def casecmp?(v1, v2); end
1484
- end
1485
-
1486
- module Rack::Utils
1487
- private
1488
-
1489
- def add_cookie_to_header(header, key, value); end
1490
- def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
1491
- def best_q_match(q_value_header, available_mimes); end
1492
- def build_nested_query(value, prefix = T.unsafe(nil)); end
1493
- def build_query(params); end
1494
- def byte_ranges(env, size); end
1495
- def clean_path_info(path_info); end
1496
- def clock_time; end
1497
- def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
1498
- def escape(s); end
1499
- def escape_html(string); end
1500
- def escape_path(s); end
1501
- def get_byte_ranges(http_range, size); end
1502
- def make_delete_cookie_header(header, key, value); end
1503
- def parse_cookies(env); end
1504
- def parse_cookies_header(header); end
1505
- def parse_nested_query(qs, d = T.unsafe(nil)); end
1506
- def parse_query(qs, d = T.unsafe(nil), &unescaper); end
1507
- def q_values(q_value_header); end
1508
- def rfc2109(time); end
1509
- def rfc2822(time); end
1510
- def secure_compare(a, b); end
1511
- def select_best_encoding(available_encodings, accept_encoding); end
1512
- def set_cookie_header!(header, key, value); end
1513
- def status_code(status); end
1514
- def unescape(s, encoding = T.unsafe(nil)); end
1515
- def unescape_path(s); end
1516
- def valid_path?(path); end
1517
-
1518
- class << self
1519
- def add_cookie_to_header(header, key, value); end
1520
- def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
1521
- def best_q_match(q_value_header, available_mimes); end
1522
- def build_nested_query(value, prefix = T.unsafe(nil)); end
1523
- def build_query(params); end
1524
- def byte_ranges(env, size); end
1525
- def clean_path_info(path_info); end
1526
- def clock_time; end
1527
- def default_query_parser; end
1528
- def default_query_parser=(_arg0); end
1529
- def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
1530
- def escape(s); end
1531
- def escape_html(string); end
1532
- def escape_path(s); end
1533
- def get_byte_ranges(http_range, size); end
1534
- def key_space_limit; end
1535
- def key_space_limit=(v); end
1536
- def make_delete_cookie_header(header, key, value); end
1537
- def multipart_part_limit; end
1538
- def multipart_part_limit=(_arg0); end
1539
- def param_depth_limit; end
1540
- def param_depth_limit=(v); end
1541
- def parse_cookies(env); end
1542
- def parse_cookies_header(header); end
1543
- def parse_nested_query(qs, d = T.unsafe(nil)); end
1544
- def parse_query(qs, d = T.unsafe(nil), &unescaper); end
1545
- def q_values(q_value_header); end
1546
- def rfc2109(time); end
1547
- def rfc2822(time); end
1548
- def secure_compare(a, b); end
1549
- def select_best_encoding(available_encodings, accept_encoding); end
1550
- def set_cookie_header!(header, key, value); end
1551
- def status_code(status); end
1552
- def unescape(s, encoding = T.unsafe(nil)); end
1553
- def unescape_path(s); end
1554
- def valid_path?(path); end
1555
- end
1556
- end
1557
-
1558
- Rack::Utils::COMMON_SEP = T.let(T.unsafe(nil), Hash)
1559
-
1560
- class Rack::Utils::Context
1561
- def initialize(app_f, app_r); end
1562
-
1563
- def app; end
1564
- def call(env); end
1565
- def context(env, app = T.unsafe(nil)); end
1566
- def for; end
1567
- def recontext(app); end
1568
- end
1569
-
1570
- Rack::Utils::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
1571
- Rack::Utils::ESCAPE_HTML = T.let(T.unsafe(nil), Hash)
1572
- Rack::Utils::ESCAPE_HTML_PATTERN = T.let(T.unsafe(nil), Regexp)
1573
- Rack::Utils::HTTP_STATUS_CODES = T.let(T.unsafe(nil), Hash)
1574
-
1575
- class Rack::Utils::HeaderHash < ::Hash
1576
- def initialize(hash = T.unsafe(nil)); end
1577
-
1578
- def [](k); end
1579
- def []=(k, v); end
1580
- def clear; end
1581
- def delete(k); end
1582
- def each; end
1583
- def has_key?(k); end
1584
- def include?(k); end
1585
- def key?(k); end
1586
- def member?(k); end
1587
- def merge(other); end
1588
- def merge!(other); end
1589
- def replace(other); end
1590
- def to_hash; end
1591
-
1592
- protected
1593
-
1594
- def names; end
1595
-
1596
- private
1597
-
1598
- def initialize_copy(other); end
1599
-
1600
- class << self
1601
- def [](headers); end
1602
- end
1603
- end
1604
-
1605
- Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError
1606
- Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params
1607
- Rack::Utils::NULL_BYTE = T.let(T.unsafe(nil), String)
1608
- Rack::Utils::PATH_SEPS = T.let(T.unsafe(nil), Regexp)
1609
- Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError
1610
- Rack::Utils::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
1611
- Rack::Utils::SYMBOL_TO_STATUS_CODE = T.let(T.unsafe(nil), Hash)
1612
- Rack::VERSION = T.let(T.unsafe(nil), Array)
1613
-
1614
- class WEBrick::HTTPResponse
1615
- def rack; end
1616
- def rack=(_arg0); end
1617
- def setup_header; end
1618
- end