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.



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 



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_options ⇒ Object 



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

def defined_options
  @defined_options ||= []
end

.inherited(klass) ⇒ Object 



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 



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 



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

#freeze ⇒ Object 



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 



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 



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_hash ⇒ Object 



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