Class: HTTPX::Session

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

Constant Summary collapse

EMPTY_HASH = 
{}.freeze

Constants included from Loggable

Loggable::COLORS

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Callbacks

#callbacks_for?, #emit, #on, #once, #only

Methods included from Chainable

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

Methods included from Loggable

#log, #log_exception

Constructor Details

#initialize(options = EMPTY_HASH, &blk) ⇒ Session

Returns a new instance of Session.



11
12
13
14
15
16
 
# File 'lib/httpx/session.rb', line 11

def initialize(options = EMPTY_HASH, &blk)
  @options = self.class.default_options.merge(options)
  @responses = {}
  @persistent = @options.persistent
  wrap(&blk) if blk
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class HTTPX::Chainable

Class Attribute Details

.default_options ⇒ Object (readonly)

Returns the value of attribute default_options.



284
285
286
 
# File 'lib/httpx/session.rb', line 284

def default_options
  @default_options
end

Class Method Details

.inherited(klass) ⇒ Object 



286
287
288
289
290
291
 
# File 'lib/httpx/session.rb', line 286

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

.plugin(pl, options = nil, &block) ⇒ Object 



293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/httpx/session.rb', line 293

def plugin(pl, options = nil, &block)
  # raise Error, "Cannot add a plugin to a frozen config" if frozen?
  pl = Plugins.load_plugin(pl) if pl.is_a?(Symbol)
  if !@plugins.include?(pl)
    @plugins << pl
    pl.load_dependencies(self, &block) if pl.respond_to?(:load_dependencies)

    @default_options = @default_options.dup

    include(pl::InstanceMethods) if defined?(pl::InstanceMethods)
    extend(pl::ClassMethods) if defined?(pl::ClassMethods)

    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)
    opts.connection_class.__send__(:include, pl::ConnectionMethods) if defined?(pl::ConnectionMethods)
    if defined?(pl::OptionsMethods)
      opts.options_class.__send__(:include, pl::OptionsMethods)

      (pl::OptionsMethods.instance_methods - Object.instance_methods).each do |meth|
        opts.options_class.method_added(meth)
      end
      @default_options = opts.options_class.new(opts)
    end

    @default_options = pl.extra_options(@default_options) if pl.respond_to?(:extra_options)
    @default_options = @default_options.merge(options) if options

    pl.configure(self, &block) if pl.respond_to?(:configure)

    @default_options.freeze
  elsif options
    # this can happen when two plugins are loaded, an one of them calls the other under the hood,
    # albeit changing some default.
    @default_options = pl.extra_options(@default_options) if pl.respond_to?(:extra_options)
    @default_options = @default_options.merge(options) if options

    @default_options.freeze
  end
  self
end

.plugins(pls) ⇒ Object

:nocov:



344
345
346
347
348
349
350
 
# File 'lib/httpx/session.rb', line 344

def plugins(pls)
  warn ":#{__method__} is deprecated, use :plugin instead"
  pls.each do |pl|
    plugin(pl)
  end
  self
end

Instance Method Details

#build_request(verb, uri, options = EMPTY_HASH) ⇒ Object 



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
70
71
72
73
74
75
 
# File 'lib/httpx/session.rb', line 43

def build_request(verb, uri, options = EMPTY_HASH)
  rklass = @options.request_class
  options = @options.merge(options) unless options.is_a?(Options)
  request = rklass.new(verb, uri, options.merge(persistent: @persistent))
  request.on(:response, &method(:on_response).curry(2)[request])
  request.on(:promise, &method(:on_promise))

  request.on(:headers) do
    emit(:request_started, request)
  end
  request.on(:body_chunk) do |chunk|
    emit(:request_body_chunk, request, chunk)
  end
  request.on(:done) do
    emit(:request_completed, request)
  end

  request.on(:response_started) do |res|
    if res.is_a?(Response)
      emit(:response_started, request, res)
      res.on(:chunk_received) do |chunk|
        emit(:response_body_chunk, request, res, chunk)
      end
    else
      emit(:request_error, request, res.error)
    end
  end
  request.on(:response) do |res|
    emit(:response_completed, request, res)
  end

  request
end

#close(*args) ⇒ Object 



29
30
31
 
# File 'lib/httpx/session.rb', line 29

def close(*args)
  pool.close(*args)
end

#request(*args, **options) ⇒ Object

Raises:

  • (ArgumentError) 


33
34
35
36
37
38
39
40
41
 
# File 'lib/httpx/session.rb', line 33

def request(*args, **options)
  raise ArgumentError, "must perform at least one request" if args.empty?

  requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
  responses = send_requests(*requests)
  return responses.first if responses.size == 1

  responses
end

#wrap ⇒ Object 



18
19
20
21
22
23
24
25
26
27
 
# File 'lib/httpx/session.rb', line 18

def wrap
  begin
    prev_persistent = @persistent
    @persistent = true
    yield self
  ensure
    @persistent = prev_persistent
    close unless @persistent
  end
end