webrick 1.8.1 → 1.9.1

data/sig/cookie.rbs

@@ -0,0 +1,37 @@
+module WEBrick
+  class Cookie
+    @expires: String?
+
+    attr_reader name: String?
+
+    attr_accessor value: String?
+
+    attr_accessor version: Integer
+
+    #
+    # The cookie domain
+    attr_accessor domain: String?
+
+    attr_accessor path: String?
+
+    attr_accessor secure: true?
+
+    attr_accessor comment: String?
+
+    attr_accessor max_age: Integer?
+
+    def initialize: (untyped name, untyped value) -> void
+
+    def expires=: ((Time | _ToS)? t) -> untyped
+
+    def expires: () -> Time?
+
+    def to_s: () -> String
+
+    def self.parse: (String? str) -> Array[instance]?
+
+    def self.parse_set_cookie: (String str) -> instance
+
+    def self.parse_set_cookies: (String str) -> Array[instance]
+  end
+end

data/sig/htmlutils.rbs

@@ -0,0 +1,5 @@
+module WEBrick
+  module HTMLUtils
+    def self?.escape: (String? string) -> String
+  end
+end

data/sig/httpauth/authenticator.rbs

@@ -0,0 +1,55 @@
+module WEBrick
+  module HTTPAuth
+    module Authenticator
+      @reload_db: bool?
+
+      @request_field: String
+
+      @response_field: String
+
+      @resp_info_field: String
+
+      @auth_exception: singleton(HTTPStatus::ClientError)
+
+      @auth_scheme: String
+
+      RequestField: String
+
+      ResponseField: String
+
+      ResponseInfoField: String
+
+      AuthException: singleton(HTTPStatus::ClientError)
+
+      AuthScheme: String?
+
+      attr_reader realm: String?
+
+      attr_reader userdb: UserDB
+
+      attr_reader logger: Log
+
+      private
+
+      def check_init: (Hash[Symbol, untyped] config) -> void
+
+      def check_scheme: (HTTPRequest req) -> String?
+
+      def log: (interned meth, String fmt, *untyped args) -> void
+
+      def error: (String fmt, *untyped args) -> void
+
+      def info: (String fmt, *untyped args) -> void
+    end
+
+    module ProxyAuthenticator
+      RequestField: String
+
+      ResponseField: String
+
+      ResponseInfoField: String
+
+      AuthException: singleton(HTTPStatus::ClientError)
+    end
+  end
+end

data/sig/httpauth/basicauth.rbs

@@ -0,0 +1,29 @@
+module WEBrick
+  module HTTPAuth
+    class BasicAuth
+      @config: Hash[Symbol, untyped]
+
+      include Authenticator
+
+      AuthScheme: String
+
+      def self.make_passwd: (String? realm, String? user, String? pass) -> String
+
+      attr_reader realm: String?
+
+      attr_reader userdb: UserDB
+
+      attr_reader logger: Log
+
+      def initialize: (Hash[Symbol, untyped] config, ?Hash[Symbol, untyped] default) -> void
+
+      def authenticate: (HTTPRequest req, HTTPResponse res) -> void
+
+      def challenge: (HTTPRequest req, HTTPResponse res) -> bot
+    end
+
+    class ProxyBasicAuth < BasicAuth
+      include ProxyAuthenticator
+    end
+  end
+end

data/sig/httpauth/digestauth.rbs

@@ -0,0 +1,85 @@
+module WEBrick
+  module HTTPAuth
+    class DigestAuth
+      @config: Hash[Symbol, untyped]
+
+      @domain: Array[String]?
+
+      @use_opaque: bool
+
+      @use_next_nonce: bool
+
+      @check_nc: bool
+
+      @use_auth_info_header: bool
+
+      @nonce_expire_period: Integer
+
+      @nonce_expire_delta: Integer
+
+      @internet_explorer_hack: bool
+
+      @h: singleton(Digest::Base)
+
+      @instance_key: String
+
+      @opaques: Hash[String, OpaqueInfo]
+
+      @last_nonce_expire: Time
+
+      @mutex: Thread::Mutex
+
+      include Authenticator
+
+      AuthScheme: String
+
+      class OpaqueInfo < Struct[untyped]
+        attr_accessor time(): Time
+        attr_accessor nonce(): String?
+        attr_accessor nc(): String
+      end
+
+      attr_reader algorithm: String?
+
+      attr_reader qop: Array[String]
+
+      def self.make_passwd: (String realm, String user, String pass) -> untyped
+
+      def initialize: (Hash[Symbol, untyped] config, ?Hash[Symbol, untyped] default) -> void
+
+      def authenticate: (HTTPRequest req, HTTPResponse res) -> void
+
+      def challenge: (HTTPRequest req, HTTPResponse res, ?bool stale) -> bot
+
+      private
+
+      MustParams: Array[String]
+
+      MustParamsAuth: Array[String]
+
+      def _authenticate: (HTTPRequest req, HTTPResponse res) -> (:nonce_is_stale | bool)
+
+      def split_param_value: (String string) -> Hash[String, String]
+
+      def generate_next_nonce: (HTTPRequest req) -> String
+
+      def check_nonce: (HTTPRequest req, Hash[String, String] auth_req) -> bool
+
+      def generate_opaque: (HTTPRequest req) -> String
+
+      def check_opaque: (OpaqueInfo opaque_struct, untyped req, Hash[String, String] auth_req) -> bool
+
+      def check_uri: (HTTPRequest req, Hash[String, String] auth_req) -> bool
+
+      def hexdigest: (*_ToS? args) -> String
+    end
+
+    class ProxyDigestAuth < DigestAuth
+      include ProxyAuthenticator
+
+      private
+
+      def check_uri: (HTTPRequest req, Hash[String, String] auth_req) -> true
+    end
+  end
+end

data/sig/httpauth/htdigest.rbs

@@ -0,0 +1,31 @@
+module WEBrick
+  module HTTPAuth
+    class Htdigest
+      @path: String
+
+      @mtime: Time
+
+      @digest: Hash[String, Hash[String, String]]
+
+      @mutex: Thread::Mutex
+
+      @auth_type: String
+
+      include UserDB
+
+      def initialize: (String path) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def get_passwd: (String realm, String user, bool reload_db) -> String?
+
+      def set_passwd: (String realm, String user, String pass) -> String
+
+      def delete_passwd: (String realm, String user) -> String?
+
+      def each: () { (String user, String realm, String password_hash) -> void } -> void
+    end
+  end
+end

data/sig/httpauth/htgroup.rbs

@@ -0,0 +1,21 @@
+module WEBrick
+  module HTTPAuth
+    class Htgroup
+      @path: String
+
+      @mtime: Time
+
+      @group: Hash[String, Array[String]]
+
+      def initialize: (String path) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def members: (String group) -> Array[String]
+
+      def add: (String group, Array[String] members) -> void
+    end
+  end
+end

data/sig/httpauth/htpasswd.rbs

@@ -0,0 +1,31 @@
+module WEBrick
+  module HTTPAuth
+    class Htpasswd
+      @path: String
+
+      @mtime: Time
+
+      @passwd: Hash[String, String]
+
+      @auth_type: String
+
+      @password_hash: (:crypt | :bcrypt)
+
+      include UserDB
+
+      def initialize: (String path, ?password_hash: (:crypt | :bcrypt)?) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def get_passwd: (String realm, String user, bool reload_db) -> String?
+
+      def set_passwd: (String realm, String user, String pass) -> void
+
+      def delete_passwd: (String realm, String user) -> String
+
+      def each: () { ([String, String]) -> void } -> void
+    end
+  end
+end

data/sig/httpauth/userdb.rbs

@@ -0,0 +1,13 @@
+module WEBrick
+  module HTTPAuth
+    module UserDB
+      attr_accessor auth_type: String
+
+      def make_passwd: (String realm, String user, String pass) -> String
+
+      def set_passwd: (String realm, String user, String pass) -> void
+
+      def get_passwd: (String realm, String user, ?bool reload_db) -> String
+    end
+  end
+end

data/sig/httpauth.rbs

@@ -0,0 +1,13 @@
+module WEBrick
+  module HTTPAuth
+    interface _Callable
+      def call: (String user, String pass) -> bool
+    end
+
+    def self?._basic_auth: (HTTPRequest req, HTTPResponse res, String realm, String req_field, String res_field, HTTPStatus::Error err_type, _Callable block) -> void
+
+    def self?.basic_auth: (HTTPRequest req, HTTPResponse res, String realm) { (String user, String pass) -> bool } -> void
+
+    def self?.proxy_basic_auth: (HTTPRequest req, HTTPResponse res, String realm) { (String user, String pass) -> bool } -> void
+  end
+end

data/sig/httpproxy.rbs

@@ -0,0 +1,61 @@
+module WEBrick
+  NullReader: untyped
+
+  def self.read: (*untyped args) -> nil
+
+  alias self.gets self.read
+
+  FakeProxyURI: untyped
+
+  def self.method_missing: (untyped meth, *untyped args) -> (nil | untyped)
+
+  class HTTPProxyServer < HTTPServer
+    @via: untyped
+
+    def initialize: (?::Hash[untyped, untyped] config, ?untyped default) -> void
+
+    # :stopdoc:
+    def service: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def proxy_auth: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def proxy_uri: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def proxy_service: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def do_CONNECT: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def do_GET: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def do_HEAD: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def do_POST: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def do_OPTIONS: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    private
+
+    # Some header fields should not be transferred.
+    HopByHop: ::Array["connection" | "keep-alive" | "proxy-authenticate" | "upgrade" | "proxy-authorization" | "te" | "trailers" | "transfer-encoding"]
+
+    ShouldNotTransfer: ::Array["set-cookie" | "proxy-connection"]
+
+    def split_field: (untyped f) -> (untyped | ::Array[untyped])
+
+    def choose_header: (untyped src, untyped dst) -> untyped
+
+    # Net::HTTP is stupid about the multiple header fields.
+    # Here is workaround:
+    def set_cookie: (untyped src, untyped dst) -> (untyped | nil)
+
+    def set_via: (untyped h) -> (untyped | nil)
+
+    def setup_proxy_header: (HTTPRequest req, HTTPResponse res) -> untyped
+
+    def setup_upstream_proxy_authentication: (HTTPRequest req, HTTPResponse res, untyped header) -> untyped
+
+    def create_net_http: (untyped uri, untyped upstream) -> untyped
+
+    def perform_proxy_request: (HTTPRequest req, HTTPResponse res, untyped req_class, ?untyped? body_stream) -> untyped
+  end
+end

data/sig/httprequest.rbs

@@ -0,0 +1,167 @@
+module WEBrick
+  class HTTPRequest
+    @config: Hash[Symbol, untyped]
+
+    @buffer_size: Integer
+
+    @logger: Log
+
+    @query: Hash[String, HTTPUtils::FormData]?
+
+    @body: String
+
+    @remaining_size: Integer?
+
+    @socket: TCPSocket?
+
+    @forwarded_proto: String?
+
+    @host: String?
+
+    @port: Integer?
+
+    @body_tmp: Array[String]
+
+    @body_rd: Fiber
+
+    @request_bytes: Integer
+
+    @forwarded_server: String?
+
+    @forwarded_host: String?
+
+    @forwarded_port: Integer?
+
+    @forwarded_for: String?
+
+    BODY_CONTAINABLE_METHODS: Array[String]
+
+    attr_reader request_line: String?
+
+    attr_reader request_method: String?
+
+    attr_reader unparsed_uri: String?
+
+    attr_reader http_version: HTTPVersion?
+
+    attr_reader request_uri: URI::Generic?
+
+    attr_reader path: String?
+
+    attr_accessor script_name: String?
+
+    attr_accessor path_info: String?
+
+    attr_accessor query_string: String?
+
+    attr_reader raw_header: Array[String]
+
+    attr_reader header: Hash[String, Array[String]]?
+
+    attr_reader cookies: Array[Cookie]
+
+    attr_reader accept: Array[String]
+
+    attr_reader accept_charset: Array[String]
+
+    attr_reader accept_encoding: Array[String]
+
+    attr_reader accept_language: Array[String]
+
+    attr_accessor user: String?
+
+    attr_reader addr: ([String, Integer, String, String] | [])
+
+    attr_reader peeraddr: ([String, Integer, String, String] | [])
+
+    attr_reader attributes: Hash[untyped, untyped]
+
+    attr_reader keep_alive: bool
+
+    attr_reader request_time: Time?
+
+    def initialize: (Hash[Symbol, untyped] config) -> void
+
+    def parse: (?TCPSocket? socket) -> void
+
+    def continue: () -> void
+
+    type body_chunk_block = ^(String body_chunk) -> void
+
+    def body: () ?{ (String body_chunk) -> void } -> String
+
+    def body_reader: () -> self
+
+    # for IO.copy_stream.
+    def readpartial: (Integer size, ?String buf) -> String
+
+    def query: () -> Hash[String, HTTPUtils::FormData]
+
+    def content_length: () -> Integer
+
+    def content_type: () -> String?
+
+    def []: (String header_name) -> String?
+
+    def each: [T] () { (String, String) -> T } -> T?
+
+    def host: () -> String?
+
+    def port: () -> Integer?
+
+    def server_name: () -> String?
+
+    def remote_ip: () -> String?
+
+    def ssl?: () -> bool
+
+    def keep_alive?: () -> bool
+
+    def to_s: () -> String
+
+    def fixup: () -> void
+
+    def meta_vars: () -> Hash[String, String]
+
+    private
+
+    MAX_URI_LENGTH: Integer
+
+    # same as Mongrel, Thin and Puma
+    MAX_HEADER_LENGTH: Integer
+
+    def read_request_line: (IO socket) -> void
+
+    def read_header: (IO socket) -> void
+
+    def parse_uri: (String str, ?String scheme) -> URI::Generic
+
+    HOST_PATTERN: Regexp
+
+    def parse_host_request_line: (String host) -> [String, String]
+
+    def read_body: (IO socket, body_chunk_block block) -> String
+                 | (nil socket, top block) -> nil
+
+    def read_chunk_size: (IO socket) -> [Integer, String?]
+
+    def read_chunked: (IO socket, body_chunk_block block) -> void
+
+    def _read_data: (IO io, Symbol method, *untyped arg) -> String?
+
+    def read_line: (IO io, ?Integer size) -> String?
+
+    def read_data: (IO io, Integer size) -> String?
+
+    def parse_query: () -> void
+
+    PrivateNetworkRegexp: Regexp
+
+    # It's said that all X-Forwarded-* headers will contain more than one
+    # (comma-separated) value if the original request already contained one of
+    # these headers. Since we could use these values as Host header, we choose
+    # the initial(first) value. (apr_table_mergen() adds new value after the
+    # existing value with ", " prefix)
+    def setup_forwarded_info: () -> void
+  end
+end

data/sig/httpresponse.rbs

@@ -0,0 +1,117 @@
+module WEBrick
+  class HTTPResponse
+    @buffer_size: Integer
+
+    @logger: Log
+
+    @chunked: bool
+
+    @bodytempfile: File | Tempfile | nil
+
+    class InvalidHeader < StandardError
+    end
+
+    attr_reader http_version: HTTPVersion
+
+    attr_reader status: Integer
+
+    attr_reader header: Hash[String, String]
+
+    attr_reader cookies: Array[Cookie]
+
+    attr_accessor reason_phrase: String
+
+    interface _CallableBody
+      def call: (_Writer) -> void
+    end
+
+    attr_accessor body: String | _ReaderPartial | _CallableBody
+
+    attr_accessor request_method: String?
+
+    attr_accessor request_uri: URI::Generic?
+
+    attr_accessor request_http_version: HTTPVersion?
+
+    attr_accessor filename: String?
+
+    attr_accessor keep_alive: bool
+
+    attr_reader config: Hash[Symbol, untyped]
+
+    attr_reader sent_size: Integer
+
+    attr_accessor upgrade: String?
+
+    def initialize: (Hash[Symbol, untyped] config) -> void
+
+    def status_line: () -> String
+
+    def status=: (Integer status) -> Integer
+
+    def []: (String field) -> String?
+
+    def []=: (String field, _ToS value) -> _ToS
+
+    def content_length: () -> Integer?
+
+    def content_length=: (Integer len) -> Integer
+
+    def content_type: () -> String?
+
+    def content_type=: (String type) -> String
+
+    def each: () { (String, String) -> void } -> void
+
+    def chunked?: () -> bool
+
+    def chunked=: (boolish val) -> boolish
+
+    def keep_alive?: () -> bool
+
+    def upgrade!: (String protocol) -> void
+
+    def send_response: (_Writer socket) -> void
+
+    def setup_header: () -> void
+
+    def make_body_tempfile: () -> void
+
+    def remove_body_tempfile: () -> void
+
+    def send_header: (_Writer socket) -> void
+
+    def send_body: (_Writer socket) -> void
+
+    def set_redirect: (singleton(WEBrick::HTTPStatus::Redirect) status, URI::Generic | String url) -> bot
+
+    def set_error: (singleton(Exception) ex, ?bool backtrace) -> void
+
+    private
+
+    def check_header: (_ToS header_value) -> String
+
+    def error_body: (bool backtrace, singleton(Exception) ex, String? host, Integer? port) -> void
+
+    def send_body_io: (_Writer socket) -> void
+
+    def send_body_string: (_Writer socket) -> void
+
+    def send_body_proc: (_Writer socket) -> void
+
+    class ChunkedWrapper
+      @socket: _Writer
+
+      @resp: HTTPResponse
+
+      def initialize: (_Writer socket, HTTPResponse resp) -> void
+
+      def write: (_ToS buf) -> Integer
+
+      def <<: (*_ToS buf) -> self
+    end
+
+    # preserved for compatibility with some 3rd-party handlers
+    def _write_data: [T] (T socket, _ToS data) -> T
+  end
+end