File: session.rbs

package info (click to toggle)
ruby-httpx 1.7.2-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 1,816 kB
  • sloc: ruby: 12,209; makefile: 4
file content (104 lines) | stat: -rw-r--r-- 3,385 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
module HTTPX
  class Session
    include Loggable
    include Chainable

    EMPTY_HASH: Hash[untyped, untyped]

    @options: Options

    # returns the HTTPX::Pool object which manages the networking required to
    # perform requests.
    @pool: Pool

    @persistent: bool
    @wrapped: bool
    @closing: bool

    type resolver = Resolver::Multi | Resolver::Resolver

    def wrap: () { (instance) -> void } -> void

    def close: (?Selector selector) -> void

    def build_request: (verb verb, generic_uri uri, ?request_params params, ?Options options) -> Request

    def select_connection: (Connection connection, Selector selector) -> void

    def pin: (resolver | Connection conn_or_resolver, Selector selector) -> void

    def deselect_connection: (Connection connection, Selector selector, ?bool cloned) -> void

    def select_resolver: (Resolver::Resolver resolver, Selector selector) -> void

    def deselect_resolver: (Resolver::Resolver resolver, Selector selector) -> void

    def try_clone_connection: (Connection connection, Selector selector, Integer? family) -> Connection

    def find_connection: (http_uri request_uri, Selector selector, Options options) -> Connection

    private

    def initialize: (?options) { (self) -> void } -> void
                  | (?options) -> void

    def selector_close: (Selector close) -> void

    def deactivate: (Selector selector) -> void

    def on_promise: (untyped, untyped) -> void

    def fetch_response: (Request request, Selector selector, Options options) -> response?

    def send_request: (Request request, Selector selector, ?Options options) -> void

    def set_request_callbacks: (Request request) -> void

    def build_requests: (verb, uri, request_params) -> Array[Request]
                      | (Array[[verb, uri] | [verb, uri, request_params]], ?request_params) -> Array[Request]
                      | (verb, _Each[[uri] | [uri, request_params]], request_params) -> Array[Request]

    def do_init_connection: (Connection connection, Selector selector) -> void

    def send_requests: (*Request) -> Array[response]

    def _send_requests: (Array[Request] requests, Selector selector) -> void

    def receive_requests: (Array[Request] requests, Selector selector) -> Array[response]

    def resolve_connection: (Connection connection, Selector selector) -> void

    def on_resolver_connection: (Connection connection, Selector selector) -> void

    def on_resolver_close: (Resolver::Resolver resolver, Selector selector) -> void

    def find_resolver_for: (Connection connection, Selector selector) -> resolver

    def coalesce_connections: (Connection conn1, Connection conn2, Selector selector, bool from_pool) -> void

    def get_current_selector: () -> Selector?
                            | () { () -> Selector } -> Selector

    def set_current_selector: (Selector? selector) -> void

    def selector_store: () -> Hash[instance, Selector]

    def thread_selector_store: (Thread th) -> Hash[instance, Selector]?

    attr_reader self.default_options: Options
    self.@plugins: Array[Module]

    def self.plugin: (Symbol | Module plugin, ?options? options) ?{ (Class) -> void } -> singleton(Session)


    INSTANCES: Hash[Session, Session]

    def self.after_fork: () -> void

    module ForkTracker
      def _fork: () -> void
    end
  end

  S: singleton(Session)
end