Class: HTTPX::Client

Inherits:
Object
  • Object
show all
Includes:
Chainable, Loggable
Defined in:
lib/httpx/client.rb

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Chainable

#accept, #headers, #plugin, #timeout, #with

Methods included from Loggable

#log

Constructor Details

#initialize(options = {}) ⇒ Client

Returns a new instance of Client.



8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/httpx/client.rb', line 8

def initialize(options = {})
  @options = self.class.default_options.merge(options)
  @connection = Connection.new(@options)
  @responses = {}
  return unless block_given?
  begin
    @keep_open = true
    yield self
  ensure
    @keep_open = false
    close
  end
end

Class Attribute Details

.default_options ⇒ Object (readonly)

Returns the value of attribute default_options.



127
128
129
 
# File 'lib/httpx/client.rb', line 127

def default_options
  @default_options
end

Class Method Details

.inherited(klass) ⇒ Object 



129
130
131
132
133
 
# File 'lib/httpx/client.rb', line 129

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

.plugin(pl, *args, &block) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/httpx/client.rb', line 135

def plugin(pl, *args, &block)
  # raise Error, "Cannot add a plugin to a frozen config" if frozen?
  pl = Plugins.load_plugin(pl) if pl.is_a?(Symbol)
  unless @plugins.include?(pl)
    @plugins << pl
    pl.load_dependencies(self, *args, &block) if pl.respond_to?(:load_dependencies)
    include(pl::InstanceMethods) if defined?(pl::InstanceMethods)
    extend(pl::ClassMethods) if defined?(pl::ClassMethods)
    if defined?(pl::OptionsMethods) || defined?(pl::OptionsClassMethods)
      options_klass = Class.new(@default_options.class)
      options_klass.extend(pl::OptionsClassMethods) if defined?(pl::OptionsClassMethods)
      options_klass.__send__(:include, pl::OptionsMethods) if defined?(pl::OptionsMethods)
      @default_options = options_klass.new
    end
    opts = default_options
    opts.request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
    opts.request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
    opts.response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
    opts.response_class.extend(pl::ResponseClassMethods) if defined?(pl::ResponseClassMethods)
    opts.headers_class.__send__(:include, pl::HeadersMethods) if defined?(pl::HeadersMethods)
    opts.headers_class.extend(pl::HeadersClassMethods) if defined?(pl::HeadersClassMethods)
    opts.request_body_class.__send__(:include, pl::RequestBodyMethods) if defined?(pl::RequestBodyMethods)
    opts.request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
    opts.response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
    opts.response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
    pl.configure(self, *args, &block) if pl.respond_to?(:configure)
  end
  self
end

.plugins(pls) ⇒ Object 



165
166
167
168
169
170
 
# File 'lib/httpx/client.rb', line 165

def plugins(pls)
  pls.each do |pl, *args|
    plugin(pl, *args)
  end
  self
end

Instance Method Details

#close ⇒ Object 



22
23
24
 
# File 'lib/httpx/client.rb', line 22

def close
  @connection.close
end

#request(*args, keep_open: @keep_open, **options) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/httpx/client.rb', line 26

def request(*args, keep_open: @keep_open, **options)
  requests = __build_reqs(*args, **options)
  responses = __send_reqs(*requests, **options)
  return responses.first if responses.size == 1
  responses
ensure
  close unless keep_open
end