187 lines
6.2 KiB
Erlang
187 lines
6.2 KiB
Erlang
%% @author Bob Ippolito <bob@mochimedia.com>
|
|
%% @copyright 2007 Mochi Media, Inc.
|
|
|
|
%% @doc Case preserving (but case insensitive) HTTP Header dictionary.
|
|
|
|
-module(mochiweb_headers).
|
|
-author('bob@mochimedia.com').
|
|
-export([empty/0, from_list/1, insert/3, enter/3, get_value/2, lookup/2]).
|
|
-export([delete_any/2, get_primary_value/2]).
|
|
-export([default/3, enter_from_list/2, default_from_list/2]).
|
|
-export([to_list/1, make/1]).
|
|
-export([test/0]).
|
|
|
|
%% @type headers().
|
|
%% @type key() = atom() | binary() | string().
|
|
%% @type value() = atom() | binary() | string() | integer().
|
|
|
|
%% @spec test() -> ok
|
|
%% @doc Run tests for this module.
|
|
test() ->
|
|
H = ?MODULE:make([{hdr, foo}, {"Hdr", "bar"}, {'Hdr', 2}]),
|
|
[{hdr, "foo, bar, 2"}] = ?MODULE:to_list(H),
|
|
H1 = ?MODULE:insert(taco, grande, H),
|
|
[{hdr, "foo, bar, 2"}, {taco, "grande"}] = ?MODULE:to_list(H1),
|
|
H2 = ?MODULE:make([{"Set-Cookie", "foo"}]),
|
|
[{"Set-Cookie", "foo"}] = ?MODULE:to_list(H2),
|
|
H3 = ?MODULE:insert("Set-Cookie", "bar", H2),
|
|
[{"Set-Cookie", "foo"}, {"Set-Cookie", "bar"}] = ?MODULE:to_list(H3),
|
|
"foo, bar" = ?MODULE:get_value("set-cookie", H3),
|
|
{value, {"Set-Cookie", "foo, bar"}} = ?MODULE:lookup("set-cookie", H3),
|
|
undefined = ?MODULE:get_value("shibby", H3),
|
|
none = ?MODULE:lookup("shibby", H3),
|
|
H4 = ?MODULE:insert("content-type",
|
|
"application/x-www-form-urlencoded; charset=utf8",
|
|
H3),
|
|
"application/x-www-form-urlencoded" = ?MODULE:get_primary_value(
|
|
"content-type", H4),
|
|
H4 = ?MODULE:delete_any("nonexistent-header", H4),
|
|
H3 = ?MODULE:delete_any("content-type", H4),
|
|
ok.
|
|
|
|
%% @spec empty() -> headers()
|
|
%% @doc Create an empty headers structure.
|
|
empty() ->
|
|
gb_trees:empty().
|
|
|
|
%% @spec make(headers() | [{key(), value()}]) -> headers()
|
|
%% @doc Construct a headers() from the given list.
|
|
make(L) when is_list(L) ->
|
|
from_list(L);
|
|
%% assume a tuple is already mochiweb_headers.
|
|
make(T) when is_tuple(T) ->
|
|
T.
|
|
|
|
%% @spec from_list([{key(), value()}]) -> headers()
|
|
%% @doc Construct a headers() from the given list.
|
|
from_list(List) ->
|
|
lists:foldl(fun ({K, V}, T) -> insert(K, V, T) end, empty(), List).
|
|
|
|
%% @spec enter_from_list([{key(), value()}], headers()) -> headers()
|
|
%% @doc Insert pairs into the headers, replace any values for existing keys.
|
|
enter_from_list(List, T) ->
|
|
lists:foldl(fun ({K, V}, T1) -> enter(K, V, T1) end, T, List).
|
|
|
|
%% @spec default_from_list([{key(), value()}], headers()) -> headers()
|
|
%% @doc Insert pairs into the headers for keys that do not already exist.
|
|
default_from_list(List, T) ->
|
|
lists:foldl(fun ({K, V}, T1) -> default(K, V, T1) end, T, List).
|
|
|
|
%% @spec to_list(headers()) -> [{key(), string()}]
|
|
%% @doc Return the contents of the headers. The keys will be the exact key
|
|
%% that was first inserted (e.g. may be an atom or binary, case is
|
|
%% preserved).
|
|
to_list(T) ->
|
|
F = fun ({K, {array, L}}, Acc) ->
|
|
L1 = lists:reverse(L),
|
|
lists:foldl(fun (V, Acc1) -> [{K, V} | Acc1] end, Acc, L1);
|
|
(Pair, Acc) ->
|
|
[Pair | Acc]
|
|
end,
|
|
lists:reverse(lists:foldl(F, [], gb_trees:values(T))).
|
|
|
|
%% @spec get_value(key(), headers()) -> string() | undefined
|
|
%% @doc Return the value of the given header using a case insensitive search.
|
|
%% undefined will be returned for keys that are not present.
|
|
get_value(K, T) ->
|
|
case lookup(K, T) of
|
|
{value, {_, V}} ->
|
|
expand(V);
|
|
none ->
|
|
undefined
|
|
end.
|
|
|
|
%% @spec get_primary_value(key(), headers()) -> string() | undefined
|
|
%% @doc Return the value of the given header up to the first semicolon using
|
|
%% a case insensitive search. undefined will be returned for keys
|
|
%% that are not present.
|
|
get_primary_value(K, T) ->
|
|
case get_value(K, T) of
|
|
undefined ->
|
|
undefined;
|
|
V ->
|
|
lists:takewhile(fun (C) -> C =/= $; end, V)
|
|
end.
|
|
|
|
%% @spec lookup(key(), headers()) -> {value, {key(), string()}} | none
|
|
%% @doc Return the case preserved key and value for the given header using
|
|
%% a case insensitive search. none will be returned for keys that are
|
|
%% not present.
|
|
lookup(K, T) ->
|
|
case gb_trees:lookup(normalize(K), T) of
|
|
{value, {K0, V}} ->
|
|
{value, {K0, expand(V)}};
|
|
none ->
|
|
none
|
|
end.
|
|
|
|
%% @spec default(key(), value(), headers()) -> headers()
|
|
%% @doc Insert the pair into the headers if it does not already exist.
|
|
default(K, V, T) ->
|
|
K1 = normalize(K),
|
|
V1 = any_to_list(V),
|
|
try gb_trees:insert(K1, {K, V1}, T)
|
|
catch
|
|
error:{key_exists, _} ->
|
|
T
|
|
end.
|
|
|
|
%% @spec enter(key(), value(), headers()) -> headers()
|
|
%% @doc Insert the pair into the headers, replacing any pre-existing key.
|
|
enter(K, V, T) ->
|
|
K1 = normalize(K),
|
|
V1 = any_to_list(V),
|
|
gb_trees:enter(K1, {K, V1}, T).
|
|
|
|
%% @spec insert(key(), value(), headers()) -> headers()
|
|
%% @doc Insert the pair into the headers, merging with any pre-existing key.
|
|
%% A merge is done with Value = V0 ++ ", " ++ V1.
|
|
insert(K, V, T) ->
|
|
K1 = normalize(K),
|
|
V1 = any_to_list(V),
|
|
try gb_trees:insert(K1, {K, V1}, T)
|
|
catch
|
|
error:{key_exists, _} ->
|
|
{K0, V0} = gb_trees:get(K1, T),
|
|
V2 = merge(K1, V1, V0),
|
|
gb_trees:update(K1, {K0, V2}, T)
|
|
end.
|
|
|
|
%% @spec delete_any(key(), headers()) -> headers()
|
|
%% @doc Delete the header corresponding to key if it is present.
|
|
delete_any(K, T) ->
|
|
K1 = normalize(K),
|
|
gb_trees:delete_any(K1, T).
|
|
|
|
%% Internal API
|
|
|
|
expand({array, L}) ->
|
|
mochiweb_util:join(lists:reverse(L), ", ");
|
|
expand(V) ->
|
|
V.
|
|
|
|
merge("set-cookie", V1, {array, L}) ->
|
|
{array, [V1 | L]};
|
|
merge("set-cookie", V1, V0) ->
|
|
{array, [V1, V0]};
|
|
merge(_, V1, V0) ->
|
|
V0 ++ ", " ++ V1.
|
|
|
|
normalize(K) when is_list(K) ->
|
|
string:to_lower(K);
|
|
normalize(K) when is_atom(K) ->
|
|
normalize(atom_to_list(K));
|
|
normalize(K) when is_binary(K) ->
|
|
normalize(binary_to_list(K)).
|
|
|
|
any_to_list(V) when is_list(V) ->
|
|
V;
|
|
any_to_list(V) when is_atom(V) ->
|
|
atom_to_list(V);
|
|
any_to_list(V) when is_binary(V) ->
|
|
binary_to_list(V);
|
|
any_to_list(V) when is_integer(V) ->
|
|
integer_to_list(V).
|
|
|
|
|