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

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 



111
112
113
114
115
116
 
# File 'lib/httpx/options.rb', line 111

def ==(other)
  ivars = instance_variables | other.instance_variables
  ivars.all? do |ivar|
    instance_variable_get(ivar) == other.instance_variable_get(ivar)
  end
end

#freeze ⇒ Object 



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

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 



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

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 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/httpx/options.rb', line 118

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 



134
135
136
137
138
139
 
# File 'lib/httpx/options.rb', line 134

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