Class: HTTPX::Options

Inherits:
Object
  • Object
show all
Defined in:
lib/httpx/options.rb

Constant Summary collapse

MAX_CONCURRENT_REQUESTS =
100
WINDOW_SIZE =

16K

1 << 14
MAX_BODY_THRESHOLD_SIZE =

112K

(1 << 10) * 112
REQUEST_IVARS =
%i[@params @form @json @body].freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Options

Returns a new instance of Options.

[View source]

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
# File 'lib/httpx/options.rb', line 42

def initialize(options = {})
  defaults = {
    :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
    :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
    :ssl => {},
    :http2_settings => { settings_enable_push: 0 },
    :fallback_protocol => "http/1.1",
    :timeout => Timeout.new,
    :headers => {},
    :max_concurrent_requests => MAX_CONCURRENT_REQUESTS,
    :window_size => WINDOW_SIZE,
    :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
    :request_class => Class.new(Request),
    :response_class => Class.new(Response),
    :headers_class => Class.new(Headers),
    :request_body_class => Class.new(Request::Body),
    :response_body_class => Class.new(Response::Body),
    :connection_class => Class.new(Connection),
    :transport => nil,
    :transport_options => nil,
    :persistent => false,
    :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
  }

  defaults.merge!(options)
  defaults[:headers] = Headers.new(defaults[:headers])
  defaults.each { |(k, v)| self[k] = v }
end

Class Method Details

.def_option(name, &interpreter) ⇒ Object

[View source]

27
28
29
30
31
32
33
34
35
36
37
38
39
# File 'lib/httpx/options.rb', line 27

def def_option(name, &interpreter)
  defined_options << name.to_sym
  interpreter ||= ->(v) { v }

  attr_accessor name
  protected :"#{name}="

  define_method(:"with_#{name}") do |value|
    other = dup
    other.send(:"#{name}=", other.instance_exec(value, &interpreter))
    other
  end
end

.defined_optionsObject

[View source]

23
24
25
# File 'lib/httpx/options.rb', line 23

def defined_options
  @defined_options ||= []
end

.inherited(klass) ⇒ Object

[View source]

10
11
12
13
# File 'lib/httpx/options.rb', line 10

def inherited(klass)
  super
  klass.instance_variable_set(:@defined_options, @defined_options.dup)
end

.new(options = {}) ⇒ Object

[View source]

15
16
17
18
19
20
21
# File 'lib/httpx/options.rb', line 15

def new(options = {})
  # let enhanced options go through
  return options if self == Options && options.class > self
  return options if options.is_a?(self)

  super
end

Instance Method Details

#==(other) ⇒ Object

[View source]

113
114
115
116
117
118
119
120
121
122
123
124
125
126
# File 'lib/httpx/options.rb', line 113

def ==(other)
  ivars = instance_variables | other.instance_variables
  ivars.all? do |ivar|
    case ivar
    when :@headers
      headers = instance_variable_get(ivar)
      headers.same_headers?(other.instance_variable_get(ivar))
    when *REQUEST_IVARS
      true
    else
      instance_variable_get(ivar) == other.instance_variable_get(ivar)
    end
  end
end

#freezeObject

[View source]

162
163
164
165
166
167
168
169
170
171
172
173
# File 'lib/httpx/options.rb', line 162

def freeze
  super

  headers.freeze
  ssl.freeze
  request_class.freeze
  response_class.freeze
  headers_class.freeze
  request_body_class.freeze
  response_body_class.freeze
  connection_class.freeze
end

#initialize_dup(other) ⇒ Object

[View source]

151
152
153
154
155
156
157
158
159
160
# File 'lib/httpx/options.rb', line 151

def initialize_dup(other)
  self.headers             = other.headers.dup
  self.ssl                 = other.ssl.dup
  self.request_class       = other.request_class.dup
  self.response_class      = other.response_class.dup
  self.headers_class       = other.headers_class.dup
  self.request_body_class  = other.request_body_class.dup
  self.response_body_class = other.response_body_class.dup
  self.connection_class    = other.connection_class.dup
end

#merge(other) ⇒ Object

[View source]

128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# File 'lib/httpx/options.rb', line 128

def merge(other)
  h1 = to_hash
  h2 = other.to_hash

  merged = h1.merge(h2) do |k, v1, v2|
    case k
    when :headers, :ssl, :http2_settings, :timeout
      v1.merge(v2)
    else
      v2
    end
  end

  self.class.new(merged)
end

#to_hashObject

[View source]

144
145
146
147
148
149
# File 'lib/httpx/options.rb', line 144

def to_hash
  hash_pairs = self.class
                   .defined_options
                   .flat_map { |opt_name| [opt_name, send(opt_name)] }
  Hash[*hash_pairs]
end