Class: HTTPX::Client

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

Constant Summary

Constants included from Loggable

Loggable::COLORS

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 = {}, &blk) ⇒ Client

Returns a new instance of Client.



8
9
10
11
12
13
14
 
# File 'lib/httpx/client.rb', line 8

def initialize(options = {}, &blk)
  @options = self.class.default_options.merge(options)
  @connection = Connection.new(@options)
  @responses = {}
  @keep_open = false
  wrap(&blk) if block_given?
end

Class Attribute Details

.default_options ⇒ Object (readonly)

Returns the value of attribute default_options.



123
124
125
 
# File 'lib/httpx/client.rb', line 123

def default_options
  @default_options
end

Class Method Details

.inherited(klass) ⇒ Object 



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

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 



131
132
133
134
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
 
# File 'lib/httpx/client.rb', line 131

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 



161
162
163
164
165
166
 
# File 'lib/httpx/client.rb', line 161

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

Instance Method Details

#close ⇒ Object 



28
29
30
 
# File 'lib/httpx/client.rb', line 28

def close
  @connection.close
end

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



32
33
34
35
36
37
38
39
 
# File 'lib/httpx/client.rb', line 32

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

#wrap ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/httpx/client.rb', line 16

def wrap
  return unless block_given?
  begin
    prev_keep_open = @keep_open
    @keep_open = true
    yield self
  ensure
    @keep_open = prev_keep_open
    close
  end
end