Module: UV::Http::Encoding

Included in:
Request
Defined in:
lib/uv-rays/http/encoding.rb

Constant Summary collapse

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

Instance Method Summary collapse

Instance Method Details

#bytesize(string) ⇒ Object 



31
32
33
 
# File 'lib/uv-rays/http/encoding.rb', line 31

def bytesize(string)
    string.bytesize
end

#encode_auth(k, v) ⇒ Object

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

String - custom auth string (OAuth, etc)



101
102
103
104
105
106
107
 
# File 'lib/uv-rays/http/encoding.rb', line 101

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

#encode_cookie(cookie) ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/uv-rays/http/encoding.rb', line 122

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

#encode_field(k, v) ⇒ Object

Encode a field in an HTTP header



94
95
96
 
# File 'lib/uv-rays/http/encoding.rb', line 94

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

#encode_headers(head) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/uv-rays/http/encoding.rb', line 109

def encode_headers(head)
    head.inject(String.new) 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

#encode_param(k, v) ⇒ Object

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



62
63
64
65
66
67
68
 
# File 'lib/uv-rays/http/encoding.rb', line 62

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

#encode_query(uri, query) ⇒ Object 



51
52
53
54
55
56
57
58
 
# File 'lib/uv-rays/http/encoding.rb', line 51

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
    encoded_query.to_s.empty? ? uri : "#{uri}?#{encoded_query}"
end

#encode_request(method, uri, query) ⇒ Object 



46
47
48
49
 
# File 'lib/uv-rays/http/encoding.rb', line 46

def encode_request(method, uri, query)
    query = encode_query(uri, query)
    String.new(HTTP_REQUEST_HEADER % [method.to_s.upcase, query])
end

#escape(s) ⇒ Object 



10
11
12
13
14
15
16
17
18
 
# File 'lib/uv-rays/http/encoding.rb', line 10

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

#form_encode_body(obj) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/uv-rays/http/encoding.rb', line 70

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

#munge_header_keys(head) ⇒ Object

Map all header keys to a downcased string version



41
42
43
 
# File 'lib/uv-rays/http/encoding.rb', line 41

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

#unescape(s) ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/uv-rays/http/encoding.rb', line 20

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