Object

     # File lib/rack/utils.rb, line 117
117:     def build_nested_query(value, prefix = nil)
118:       case value
119:       when Array
120:         value.map { |v|
121:           build_nested_query(v, "#{prefix}[]")
122:         }.join("&")
123:       when Hash
124:         value.map { |k, v|
125:           build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
126:         }.join("&")
127:       when String
128:         raise ArgumentError, "value must be a Hash" if prefix.nil?
129:         "#{prefix}=#{escape(value)}"
130:       else
131:         prefix
132:       end
133:     end

     # File lib/rack/utils.rb, line 106
106:     def build_query(params)
107:       params.map { |k, v|
108:         if v.class == Array
109:           build_query(v.map { |x| [k, x] })
110:         else
111:           "#{escape(k)}=#{escape(v)}"
112:         end
113:       }.join("&")
114:     end

     # File lib/rack/utils.rb, line 227
227:       def bytesize(string)
228:         string.bytesize
229:       end

     # File lib/rack/utils.rb, line 231
231:       def bytesize(string)
232:         string.size
233:       end

     # File lib/rack/utils.rb, line 207
207:     def delete_cookie_header!(header, key, value = {})
208:       unless Array === header["Set-Cookie"]
209:         header["Set-Cookie"] = [header["Set-Cookie"]].compact
210:       end
211: 
212:       header["Set-Cookie"].reject! { |cookie|
213:         cookie =~ /\A#{escape(key)}=/
214:       }
215: 
216:       set_cookie_header!(header, key,
217:                  {:value => '', :path => nil, :domain => nil,
218:                    :expires => Time.at(0) }.merge(value))
219: 
220:       nil
221:     end

     # File lib/rack/utils.rb, line 137
137:     def escape_html(string)
138:       string.to_s.gsub("&", "&").
139:         gsub("<", "&lt;").
140:         gsub(">", "&gt;").
141:         gsub("'", "&#39;").
142:         gsub('"', "&quot;")
143:     end

     # File lib/rack/utils.rb, line 71
 71:     def normalize_params(params, name, v = nil)
 72:       if v and v =~ /^("|')(.*)\1$/
 73:         v = $2.gsub('\\'+$1, $1)
 74:       end
 75:       name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
 76:       k = $1 || ''
 77:       after = $' || ''
 78: 
 79:       return if k.empty?
 80: 
 81:       if after == ""
 82:         params[k] = v
 83:       elsif after == "[]"
 84:         params[k] ||= []
 85:         raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
 86:         params[k] << v
 87:       elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
 88:         child_key = $1
 89:         params[k] ||= []
 90:         raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
 91:         if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
 92:           normalize_params(params[k].last, child_key, v)
 93:         else
 94:           params[k] << normalize_params({}, child_key, v)
 95:         end
 96:       else
 97:         params[k] ||= {}
 98:         raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
 99:         params[k] = normalize_params(params[k], after, v)
100:       end
101: 
102:       return params
103:     end

     # File lib/rack/utils.rb, line 146
146:     def select_best_encoding(available_encodings, accept_encoding)
147:       # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
148: 
149:       expanded_accept_encoding =
150:         accept_encoding.map { |m, q|
151:           if m == "*"
152:             (available_encodings - accept_encoding.map { |m2, _| m2 }).map { |m2| [m2, q] }
153:           else
154:             [[m, q]]
155:           end
156:         }.inject([]) { |mem, list|
157:           mem + list
158:         }
159: 
160:       encoding_candidates = expanded_accept_encoding.sort_by { |_, q| -q }.map { |m, _| m }
161: 
162:       unless encoding_candidates.include?("identity")
163:         encoding_candidates.push("identity")
164:       end
165: 
166:       expanded_accept_encoding.find_all { |m, q|
167:         q == 0.0
168:       }.each { |m, _|
169:         encoding_candidates.delete(m)
170:       }
171: 
172:       return (encoding_candidates & available_encodings)[0]
173:     end

     # File lib/rack/utils.rb, line 176
176:     def set_cookie_header!(header, key, value)
177:       case value
178:       when Hash
179:         domain  = "; domain="  + value[:domain] if value[:domain]
180:         path    = "; path="    + value[:path]   if value[:path]
181:         # According to RFC 2109, we need dashes here.
182:         # N.B.: cgi.rb uses spaces...
183:         expires = "; expires=" + value[:expires].clone.gmtime.
184:           strftime("%a, %d-%b-%Y %H:%M:%S GMT") if value[:expires]
185:         secure = "; secure"  if value[:secure]
186:         httponly = "; HttpOnly" if value[:httponly]
187:         value = value[:value]
188:       end
189:       value = [value] unless Array === value
190:       cookie = escape(key) + "=" +
191:         value.map { |v| escape v }.join("&") +
192:         "#{domain}#{path}#{expires}#{secure}#{httponly}"
193: 
194:       case header["Set-Cookie"]
195:       when Array
196:         header["Set-Cookie"] << cookie
197:       when String
198:         header["Set-Cookie"] = [header["Set-Cookie"], cookie]
199:       when nil
200:         header["Set-Cookie"] = cookie
201:       end
202: 
203:       nil
204:     end

     # File lib/rack/utils.rb, line 402
402:     def status_code(status)
403:       if status.is_a?(Symbol)
404:         SYMBOL_TO_STATUS_CODE[status] || 500
405:       else
406:         status.to_i
407:       end
408:     end