Module: EventMachine::HttpEncoding

Included in:
HttpClient, Middleware::DigestAuth, Middleware::OAuth
Defined in:
lib/em-http/http_encoding.rb

Constant Summary

HTTP_REQUEST_HEADER =
"%s %s HTTP/1.1\r\n"
FIELD_ENCODING =
"%s: %s\r\n"

Instance Method Summary (collapse)

Instance Method Details

- (Object) bytesize(string)



27
28
29
# File 'lib/em-http/http_encoding.rb', line 27

def bytesize(string)
  string.bytesize
end

- (Object) encode_auth(k, v)

Encode basic auth in an HTTP header In: Array ([user, pass]) - for basic auth

String - custom auth string (OAuth, etc)


113
114
115
116
117
118
119
# File 'lib/em-http/http_encoding.rb', line 113

def encode_auth(k,v)
  if v.is_a? Array
    FIELD_ENCODING % [k, ["Basic", Base64.encode64(v.join(":")).split.join].join(" ")]
  else
    encode_field(k,v)
  end
end


134
135
136
137
138
139
140
# File 'lib/em-http/http_encoding.rb', line 134

def encode_cookie(cookie)
  if cookie.is_a? Hash
    cookie.inject('') { |result, (k, v)| result <<  encode_param(k, v) + ";" }
  else
    cookie
  end
end

- (Object) encode_field(k, v)

Encode a field in an HTTP header



106
107
108
# File 'lib/em-http/http_encoding.rb', line 106

def encode_field(k, v)
  FIELD_ENCODING % [k, v]
end

- (Object) encode_headers(head)



121
122
123
124
125
126
127
128
129
130
131
132
# File 'lib/em-http/http_encoding.rb', line 121

def encode_headers(head)
  head.inject('') do |result, (key, value)|
    # Munge keys from foo-bar-baz to Foo-Bar-Baz
    key = key.split('-').map { |k| k.to_s.capitalize }.join('-')
    result << case key
      when 'Authorization', 'Proxy-Authorization'
        encode_auth(key, value)
      else
        encode_field(key, value)
    end
  end
end

- (Object) encode_host



41
42
43
44
45
46
47
# File 'lib/em-http/http_encoding.rb', line 41

def encode_host
  if @req.uri.port.nil? || @req.uri.port == 80 || @req.uri.port == 443
    return @req.uri.host
  else
    @req.uri.host + ":#{@req.uri.port}"
  end
end

- (Object) encode_param(k, v)

URL encodes query parameters: single k=v, or a URL encoded array, if v is an array of values



74
75
76
77
78
79
80
# File 'lib/em-http/http_encoding.rb', line 74

def encode_param(k, v)
  if v.is_a?(Array)
    v.map { |e| escape(k) + "[]=" + escape(e) }.join("&")
  else
    escape(k) + "=" + escape(v)
  end
end

- (Object) encode_query(uri, query)



59
60
61
62
63
64
65
66
67
68
69
70
# File 'lib/em-http/http_encoding.rb', line 59

def encode_query(uri, query)
  encoded_query = if query.kind_of?(Hash)
    query.map { |k, v| encode_param(k, v) }.join('&')
  else
    query.to_s
  end

  if uri && !uri.query.to_s.empty?
    encoded_query = [encoded_query, uri.query].reject {|part| part.empty?}.join("&")
  end
  encoded_query.to_s.empty? ? uri.path : "#{uri.path}?#{encoded_query}"
end

- (Object) encode_request(method, uri, query, proxy)



49
50
51
52
53
54
55
56
57
# File 'lib/em-http/http_encoding.rb', line 49

def encode_request(method, uri, query, proxy)
  query = encode_query(uri, query)

  # Non CONNECT proxies require that you provide the full request
  # uri in request header, as opposed to a relative path.
  query = uri.join(query) if proxy

  HTTP_REQUEST_HEADER % [method.to_s.upcase, query]
end

- (Object) escape(s)



6
7
8
9
10
11
12
13
14
# File 'lib/em-http/http_encoding.rb', line 6

def escape(s)
  if defined?(EscapeUtils)
    EscapeUtils.escape_url(s.to_s)
  else
    s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/) {
      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
    }
  end
end

- (Object) form_encode_body(obj)



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
# File 'lib/em-http/http_encoding.rb', line 82

def form_encode_body(obj)
  pairs = []
  recursive = Proc.new do |h, prefix|
    h.each do |k,v|
      key = prefix == '' ? escape(k) : "#{prefix}[#{escape(k)}]"

      if v.is_a? Array
        nh = Hash.new
        v.size.times { |t| nh[t] = v[t] }
        recursive.call(nh, key)

      elsif v.is_a? Hash
        recursive.call(v, key)
      else
        pairs << "#{key}=#{escape(v)}"
      end
    end
  end

  recursive.call(obj, '')
  return pairs.join('&')
end

- (Object) munge_header_keys(head)

Map all header keys to a downcased string version



37
38
39
# File 'lib/em-http/http_encoding.rb', line 37

def munge_header_keys(head)
  head.inject({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
end

- (Object) unescape(s)



16
17
18
19
20
21
22
23
24
# File 'lib/em-http/http_encoding.rb', line 16

def unescape(s)
  if defined?(EscapeUtils)
    EscapeUtils.unescape_url(s.to_s)
  else
    s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/) {
      [$1.delete('%')].pack('H*')
    }
  end
end