Method: Faraday::Request#headers

Defined in:
lib/faraday/request.rb

#headers ⇒ Faraday::Utils::Headers

Returns headers.

Returns:



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/faraday/request.rb', line 27

Request = Struct.new(:http_method, :path, :params, :headers, :body, :options) do
  extend MiddlewareRegistry

  alias_method :member_get, :[]
  private :member_get
  alias_method :member_set, :[]=
  private :member_set

  # @param request_method [String]
  # @yield [request] for block customization, if block given
  # @yieldparam request [Request]
  # @return [Request]
  def self.create(request_method)
    new(request_method).tap do |request|
      yield(request) if block_given?
    end
  end

  remove_method :params=
  # Replace params, preserving the existing hash type.
  #
  # @param hash [Hash] new params
  def params=(hash)
    if params
      params.replace hash
    else
      member_set(:params, hash)
    end
  end

  remove_method :headers=
  # Replace request headers, preserving the existing hash type.
  #
  # @param hash [Hash] new headers
  def headers=(hash)
    if headers
      headers.replace hash
    else
      member_set(:headers, hash)
    end
  end

  # Update path and params.
  #
  # @param path [URI, String]
  # @param params [Hash, nil]
  # @return [void]
  def url(path, params = nil)
    if path.respond_to? :query
      if (query = path.query)
        path = path.dup
        path.query = nil
      end
    else
      anchor_index = path.index('#')
      path = path.slice(0, anchor_index) unless anchor_index.nil?
      path, query = path.split('?', 2)
    end
    self.path = path
    self.params.merge_query query, options.params_encoder
    self.params.update(params) if params
  end

  # @param key [Object] key to look up in headers
  # @return [Object] value of the given header name
  def [](key)
    headers[key]
  end

  # @param key [Object] key of header to write
  # @param value [Object] value of header
  def []=(key, value)
    headers[key] = value
  end

  # Marshal serialization support.
  #
  # @return [Hash] the hash ready to be serialized in Marshal.
  def marshal_dump
    {
      http_method: http_method,
      body: body,
      headers: headers,
      path: path,
      params: params,
      options: options
    }
  end

  # Marshal serialization support.
  # Restores the instance variables according to the +serialised+.
  # @param serialised [Hash] the serialised object.
  def marshal_load(serialised)
    self.http_method = serialised[:http_method]
    self.body = serialised[:body]
    self.headers = serialised[:headers]
    self.path = serialised[:path]
    self.params = serialised[:params]
    self.options = serialised[:options]
  end

  # @return [Env] the Env for this Request
  def to_env(connection)
    Env.new(http_method, body, connection.build_exclusive_url(path, params),
            options, headers, connection.ssl, connection.parallel_manager)
  end
end