src/mochifmt.erl - couchdb-mochiweb - Git at Google

 %% @author Bob Ippolito <bob@mochimedia.com>
 %% @copyright 2008 Mochi Media, Inc.
 %%
 %% Permission is hereby granted, free of charge, to any person obtaining a
 %% copy of this software and associated documentation files (the "Software"),
 %% to deal in the Software without restriction, including without limitation
 %% the rights to use, copy, modify, merge, publish, distribute, sublicense,
 %% and/or sell copies of the Software, and to permit persons to whom the
 %% Software is furnished to do so, subject to the following conditions:
 %%
 %% The above copyright notice and this permission notice shall be included in
 %% all copies or substantial portions of the Software.
 %%
 %% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 %% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 %% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 %% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 %% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 %% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 %% DEALINGS IN THE SOFTWARE.

 %% @doc String Formatting for Erlang, inspired by Python 2.6
 %%      (<a href="http://www.python.org/dev/peps/pep-3101/">PEP 3101</a>).
 %%
 -module(mochifmt).

 -author('bob@mochimedia.com').

 -export([convert_field/2, format/2, format_field/2,
 	 get_field/2, get_value/2]).

 -export([format/3, format_field/3, get_field/3,
 	 tokenize/1]).

 -export([bformat/2, bformat/3]).

 -export([f/2, f/3]).

 -record(conversion,
 	{length, precision, ctype, align, fill_char, sign}).

 %% @spec tokenize(S::string()) -> tokens()
 %% @doc Tokenize a format string into mochifmt's internal format.
 tokenize(S) -> {?MODULE, tokenize(S, "", [])}.

 %% @spec convert_field(Arg, Conversion::conversion()) -> term()
 %% @doc Process Arg according to the given explicit conversion specifier.
 convert_field(Arg, "") -> Arg;
 convert_field(Arg, "r") -> repr(Arg);
 convert_field(Arg, "s") -> str(Arg).

 %% @spec get_value(Key::string(), Args::args()) -> term()
 %% @doc Get the Key from Args. If Args is a tuple then convert Key to
 %%      an integer and get element(1 + Key, Args). If Args is a list and Key
 %%      can be parsed as an integer then use lists:nth(1 + Key, Args),
 %%      otherwise try and look for Key in Args as a proplist, converting
 %%      Key to an atom or binary if necessary.
 get_value(Key, Args) when is_tuple(Args) ->
     element(1 + list_to_integer(Key), Args);
 get_value(Key, Args) when is_list(Args) ->
     try lists:nth(1 + list_to_integer(Key), Args) catch
       error:_ -> {_K, V} = proplist_lookup(Key, Args), V
     end.

 %% @spec get_field(Key::string(), Args) -> term()
 %% @doc Consecutively call get_value/2 on parts of Key delimited by ".",
 %%      replacing Args with the result of the previous get_value. This
 %%      is used to implement formats such as {0.0}.
 get_field(Key, Args) -> get_field(Key, Args, ?MODULE).

 %% @spec get_field(Key::string(), Args, Module) -> term()
 %% @doc Consecutively call Module:get_value/2 on parts of Key delimited by ".",
 %%      replacing Args with the result of the previous get_value. This
 %%      is used to implement formats such as {0.0}.
 get_field(Key, Args, Module) ->
     {Name, Next} = lists:splitwith(fun (C) -> C =/= $. end,
 				   Key),
     Res = mod_get_value(Name, Args, Module),
     case Next of
       "" -> Res;
       "." ++ S1 -> get_field(S1, Res, Module)
     end.

 mod_get_value(Name, Args, Module) ->
     try tuple_apply(Module, get_value, [Name, Args]) catch
       error:undef -> get_value(Name, Args)
     end.

 tuple_apply(Module, F, Args) when is_atom(Module) ->
     erlang:apply(Module, F, Args);
 tuple_apply(Module, F, Args)
     when is_tuple(Module), is_atom(element(1, Module)) ->
     erlang:apply(element(1, Module), F, Args ++ [Module]).

 %% @spec format(Format::string(), Args) -> iolist()
 %% @doc Format Args with Format.
 format(Format, Args) -> format(Format, Args, ?MODULE).

 %% @spec format(Format::string(), Args, Module) -> iolist()
 %% @doc Format Args with Format using Module.
 format({?MODULE, Parts}, Args, Module) ->
     format2(Parts, Args, Module, []);
 format(S, Args, Module) ->
     format(tokenize(S), Args, Module).

 %% @spec format_field(Arg, Format) -> iolist()
 %% @doc Format Arg with Format.
 format_field(Arg, Format) ->
     format_field(Arg, Format, ?MODULE).

 %% @spec format_field(Arg, Format, _Module) -> iolist()
 %% @doc Format Arg with Format.
 format_field(Arg, Format, _Module) ->
     F = default_ctype(Arg, parse_std_conversion(Format)),
     fix_padding(fix_sign(convert2(Arg, F), F), F).

 %% @spec f(Format::string(), Args) -> string()
 %% @doc Format Args with Format and return a string().
 f(Format, Args) -> f(Format, Args, ?MODULE).

 %% @spec f(Format::string(), Args, Module) -> string()
 %% @doc Format Args with Format using Module and return a string().
 f(Format, Args, Module) ->
     case lists:member(${, Format) of
       true -> binary_to_list(bformat(Format, Args, Module));
       false -> Format
     end.

 %% @spec bformat(Format::string(), Args) -> binary()
 %% @doc Format Args with Format and return a binary().
 bformat(Format, Args) ->
     iolist_to_binary(format(Format, Args)).

 %% @spec bformat(Format::string(), Args, Module) -> binary()
 %% @doc Format Args with Format using Module and return a binary().
 bformat(Format, Args, Module) ->
     iolist_to_binary(format(Format, Args, Module)).

 %% Internal API

 add_raw("", Acc) -> Acc;
 add_raw(S, Acc) -> [{raw, lists:reverse(S)} | Acc].

 tokenize([], S, Acc) -> lists:reverse(add_raw(S, Acc));
 tokenize("{{" ++ Rest, S, Acc) ->
     tokenize(Rest, "{" ++ S, Acc);
 tokenize("{" ++ Rest, S, Acc) ->
     {Format, Rest1} = tokenize_format(Rest),
     tokenize(Rest1, "",
 	     [{format, make_format(Format)} | add_raw(S, Acc)]);
 tokenize("}}" ++ Rest, S, Acc) ->
     tokenize(Rest, "}" ++ S, Acc);
 tokenize([C | Rest], S, Acc) ->
     tokenize(Rest, [C | S], Acc).

 tokenize_format(S) -> tokenize_format(S, 1, []).

 tokenize_format("}" ++ Rest, 1, Acc) ->
     {lists:reverse(Acc), Rest};
 tokenize_format("}" ++ Rest, N, Acc) ->
     tokenize_format(Rest, N - 1, "}" ++ Acc);
 tokenize_format("{" ++ Rest, N, Acc) ->
     tokenize_format(Rest, 1 + N, "{" ++ Acc);
 tokenize_format([C | Rest], N, Acc) ->
     tokenize_format(Rest, N, [C | Acc]).

 make_format(S) ->
     {Name0, Spec} = case lists:splitwith(fun (C) -> C =/= $:
 					 end,
 					 S)
 			of
 		      {_, ""} -> {S, ""};
 		      {SN, ":" ++ SS} -> {SN, SS}
 		    end,
     {Name, Transform} = case lists:splitwith(fun (C) ->
 						     C =/= $!
 					     end,
 					     Name0)
 			    of
 			  {_, ""} -> {Name0, ""};
 			  {TN, "!" ++ TT} -> {TN, TT}
 			end,
     {Name, Transform, Spec}.

 proplist_lookup(S, P) ->
     A = try list_to_existing_atom(S) catch
 	  error:_ -> make_ref()
 	end,
     B = try list_to_binary(S) catch
 	  error:_ -> make_ref()
 	end,
     proplist_lookup2({S, A, B}, P).

 proplist_lookup2({KS, KA, KB}, [{K, V} | _])
     when KS =:= K orelse KA =:= K orelse KB =:= K ->
     {K, V};
 proplist_lookup2(Keys, [_ | Rest]) ->
     proplist_lookup2(Keys, Rest).

 format2([], _Args, _Module, Acc) -> lists:reverse(Acc);
 format2([{raw, S} | Rest], Args, Module, Acc) ->
     format2(Rest, Args, Module, [S | Acc]);
 format2([{format, {Key, Convert, Format0}} | Rest],
 	Args, Module, Acc) ->
     Format = f(Format0, Args, Module),
     V = case Module of
 	  ?MODULE ->
 	      V0 = get_field(Key, Args),
 	      V1 = convert_field(V0, Convert),
 	      format_field(V1, Format);
 	  _ ->
 	      V0 = try tuple_apply(Module, get_field, [Key, Args])
 		   catch
 		     error:undef -> get_field(Key, Args, Module)
 		   end,
 	      V1 = try tuple_apply(Module, convert_field,
 				   [V0, Convert])
 		   catch
 		     error:undef -> convert_field(V0, Convert)
 		   end,
 	      try tuple_apply(Module, format_field, [V1, Format])
 	      catch
 		error:undef -> format_field(V1, Format, Module)
 	      end
 	end,
     format2(Rest, Args, Module, [V | Acc]).

 default_ctype(_Arg, C = #conversion{ctype = N})
     when N =/= undefined ->
     C;
 default_ctype(Arg, C) when is_integer(Arg) ->
     C#conversion{ctype = decimal};
 default_ctype(Arg, C) when is_float(Arg) ->
     C#conversion{ctype = general};
 default_ctype(_Arg, C) -> C#conversion{ctype = string}.

 fix_padding(Arg, #conversion{length = undefined}) ->
     Arg;
 fix_padding(Arg,
 	    F = #conversion{length = Length, fill_char = Fill0,
 			    align = Align0, ctype = Type}) ->
     Padding = Length - iolist_size(Arg),
     Fill = case Fill0 of
 	     undefined -> $\s;
 	     _ -> Fill0
 	   end,
     Align = case Align0 of
 	      undefined ->
 		  case Type of
 		    string -> left;
 		    _ -> right
 		  end;
 	      _ -> Align0
 	    end,
     case Padding > 0 of
       true -> do_padding(Arg, Padding, Fill, Align, F);
       false -> Arg
     end.

 do_padding(Arg, Padding, Fill, right, _F) ->
     [lists:duplicate(Padding, Fill), Arg];
 do_padding(Arg, Padding, Fill, center, _F) ->
     LPadding = lists:duplicate(Padding div 2, Fill),
     RPadding = case Padding band 1 of
 		 1 -> [Fill | LPadding];
 		 _ -> LPadding
 	       end,
     [LPadding, Arg, RPadding];
 do_padding([$- | Arg], Padding, Fill, sign_right, _F) ->
     [[$- | lists:duplicate(Padding, Fill)], Arg];
 do_padding(Arg, Padding, Fill, sign_right,
 	   #conversion{sign = $-}) ->
     [lists:duplicate(Padding, Fill), Arg];
 do_padding([S | Arg], Padding, Fill, sign_right,
 	   #conversion{sign = S}) ->
     [[S | lists:duplicate(Padding, Fill)], Arg];
 do_padding(Arg, Padding, Fill, sign_right,
 	   #conversion{sign = undefined}) ->
     [lists:duplicate(Padding, Fill), Arg];
 do_padding(Arg, Padding, Fill, left, _F) ->
     [Arg | lists:duplicate(Padding, Fill)].

 fix_sign(Arg, #conversion{sign = $+}) when Arg >= 0 ->
     [$+, Arg];
 fix_sign(Arg, #conversion{sign = $\s}) when Arg >= 0 ->
     [$\s, Arg];
 fix_sign(Arg, _F) -> Arg.

 ctype($%) -> percent;
 ctype($s) -> string;
 ctype($b) -> bin;
 ctype($o) -> oct;
 ctype($X) -> upper_hex;
 ctype($x) -> hex;
 ctype($c) -> char;
 ctype($d) -> decimal;
 ctype($g) -> general;
 ctype($f) -> fixed;
 ctype($e) -> exp.

 align($<) -> left;
 align($>) -> right;
 align($^) -> center;
 align($=) -> sign_right.

 convert2(Arg, F = #conversion{ctype = percent}) ->
     [convert2(1.0e+2 * Arg, F#conversion{ctype = fixed}),
      $%];
 convert2(Arg, #conversion{ctype = string}) -> str(Arg);
 convert2(Arg, #conversion{ctype = bin}) ->
     erlang:integer_to_list(Arg, 2);
 convert2(Arg, #conversion{ctype = oct}) ->
     erlang:integer_to_list(Arg, 8);
 convert2(Arg, #conversion{ctype = upper_hex}) ->
     erlang:integer_to_list(Arg, 16);
 convert2(Arg, #conversion{ctype = hex}) ->
     string:to_lower(erlang:integer_to_list(Arg, 16));
 convert2(Arg, #conversion{ctype = char})
     when Arg < 128 ->
     [Arg];
 convert2(Arg, #conversion{ctype = char}) ->
     xmerl_ucs:to_utf8(Arg);
 convert2(Arg, #conversion{ctype = decimal}) ->
     integer_to_list(Arg);
 convert2(Arg,
 	 #conversion{ctype = general, precision = undefined}) ->
     try mochinum:digits(Arg) catch
       error:undef -> io_lib:format("~g", [Arg])
     end;
 convert2(Arg,
 	 #conversion{ctype = fixed, precision = undefined}) ->
     io_lib:format("~f", [Arg]);
 convert2(Arg,
 	 #conversion{ctype = exp, precision = undefined}) ->
     io_lib:format("~e", [Arg]);
 convert2(Arg,
 	 #conversion{ctype = general, precision = P}) ->
     io_lib:format("~." ++ integer_to_list(P) ++ "g", [Arg]);
 convert2(Arg,
 	 #conversion{ctype = fixed, precision = P}) ->
     io_lib:format("~." ++ integer_to_list(P) ++ "f", [Arg]);
 convert2(Arg,
 	 #conversion{ctype = exp, precision = P}) ->
     io_lib:format("~." ++ integer_to_list(P) ++ "e", [Arg]).

 str(A) when is_atom(A) -> atom_to_list(A);
 str(I) when is_integer(I) -> integer_to_list(I);
 str(F) when is_float(F) ->
     try mochinum:digits(F) catch
       error:undef -> io_lib:format("~g", [F])
     end;
 str(L) when is_list(L) -> L;
 str(B) when is_binary(B) -> B;
 str(P) -> repr(P).

 repr(P) when is_float(P) ->
     try mochinum:digits(P) catch
       error:undef -> float_to_list(P)
     end;
 repr(P) -> io_lib:format("~p", [P]).

 parse_std_conversion(S) ->
     parse_std_conversion(S, #conversion{}).

 parse_std_conversion("", Acc) -> Acc;
 parse_std_conversion([Fill, Align | Spec], Acc)
     when Align =:= $< orelse
 	   Align =:= $> orelse Align =:= $= orelse Align =:= $^ ->
     parse_std_conversion(Spec,
 			 Acc#conversion{fill_char = Fill,
 					align = align(Align)});
 parse_std_conversion([Align | Spec], Acc)
     when Align =:= $< orelse
 	   Align =:= $> orelse Align =:= $= orelse Align =:= $^ ->
     parse_std_conversion(Spec,
 			 Acc#conversion{align = align(Align)});
 parse_std_conversion([Sign | Spec], Acc)
     when Sign =:= $+ orelse
 	   Sign =:= $- orelse Sign =:= $\s ->
     parse_std_conversion(Spec, Acc#conversion{sign = Sign});
 parse_std_conversion("0" ++ Spec, Acc) ->
     Align = case Acc#conversion.align of
 	      undefined -> sign_right;
 	      A -> A
 	    end,
     parse_std_conversion(Spec,
 			 Acc#conversion{fill_char = $0, align = Align});
 parse_std_conversion(Spec = [D | _], Acc)
     when D >= $0 andalso D =< $9 ->
     {W, Spec1} = lists:splitwith(fun (C) ->
 					 C >= $0 andalso C =< $9
 				 end,
 				 Spec),
     parse_std_conversion(Spec1,
 			 Acc#conversion{length = list_to_integer(W)});
 parse_std_conversion([$. | Spec], Acc) ->
     case lists:splitwith(fun (C) -> C >= $0 andalso C =< $9
 			 end,
 			 Spec)
 	of
       {"", Spec1} -> parse_std_conversion(Spec1, Acc);
       {P, Spec1} ->
 	  parse_std_conversion(Spec1,
 			       Acc#conversion{precision = list_to_integer(P)})
     end;
 parse_std_conversion([Type], Acc) ->
     parse_std_conversion("",
 			 Acc#conversion{ctype = ctype(Type)}).

 %%
 %% Tests
 %%
 -ifdef(TEST).

 -include_lib("eunit/include/eunit.hrl").

 tokenize_test() ->
     {?MODULE, [{raw, "ABC"}]} = tokenize("ABC"),
     {?MODULE, [{format, {"0", "", ""}}]} = tokenize("{0}"),
     {?MODULE,
      [{raw, "ABC"}, {format, {"1", "", ""}}, {raw, "DEF"}]} =
 	tokenize("ABC{1}DEF"),
     ok.

 format_test() ->
     <<"  -4">> = bformat("{0:4}", [-4]),
     <<"   4">> = bformat("{0:4}", [4]),
     <<"   4">> = bformat("{0:{0}}", [4]),
     <<"4   ">> = bformat("{0:4}", ["4"]),
     <<"4   ">> = bformat("{0:{0}}", ["4"]),
     <<"1.2yoDEF">> = bformat("{2}{0}{1}{3}",
 			     {yo, "DE", 1.19999999999999995559, <<"F">>}),
     <<"cafebabe">> = bformat("{0:x}", {3405691582}),
     <<"CAFEBABE">> = bformat("{0:X}", {3405691582}),
     <<"CAFEBABE">> = bformat("{0:X}", {3405691582}),
     <<"755">> = bformat("{0:o}", {493}),
     <<"a">> = bformat("{0:c}", {97}),
     %% Horizontal ellipsis
     <<226, 128, 166>> = bformat("{0:c}", {8230}),
     <<"11">> = bformat("{0:b}", {3}),
     <<"11">> = bformat("{0:b}", [3]),
     <<"11">> = bformat("{three:b}", [{three, 3}]),
     <<"11">> = bformat("{three:b}", [{"three", 3}]),
     <<"11">> = bformat("{three:b}", [{<<"three">>, 3}]),
     <<"\"foo\"">> = bformat("{0!r}", {"foo"}),
     <<"2008-5-4">> = bformat("{0.0}-{0.1}-{0.2}",
 			     {{2008, 5, 4}}),
     <<"2008-05-04">> = bformat("{0.0:04}-{0.1:02}-{0.2:02}",
 			       {{2008, 5, 4}}),
     <<"foo6bar-6">> = bformat("foo{1}{0}-{1}", {bar, 6}),
     <<"-'atom test'-">> = bformat("-{arg!r}-",
 				  [{arg, 'atom test'}]),
     <<"2008-05-04">> =
 	bformat("{0.0:0{1.0}}-{0.1:0{1.1}}-{0.2:0{1.2}}",
 		{{2008, 5, 4}, {4, 2, 2}}),
     ok.

 std_test() ->
     M = mochifmt_std:new(),
     <<"01">> = bformat("{0}{1}", [0, 1], M),
     ok.

 records_test() ->
     M = mochifmt_records:new([{conversion,
 			       record_info(fields, conversion)}]),
     R = #conversion{length = long, precision = hard,
 		    sign = peace},
     long = mochifmt_records:get_value("length", R, M),
     hard = mochifmt_records:get_value("precision", R, M),
     peace = mochifmt_records:get_value("sign", R, M),
     <<"long hard">> = bformat("{length} {precision}", R, M),
     <<"long hard">> = bformat("{0.length} {0.precision}",
 			      [R], M),
     ok.

 -endif.
	%% @author Bob Ippolito <bob@mochimedia.com>
	%% @copyright 2008 Mochi Media, Inc.
	%%
	%% Permission is hereby granted, free of charge, to any person obtaining a
	%% copy of this software and associated documentation files (the "Software"),
	%% to deal in the Software without restriction, including without limitation
	%% the rights to use, copy, modify, merge, publish, distribute, sublicense,
	%% and/or sell copies of the Software, and to permit persons to whom the
	%% Software is furnished to do so, subject to the following conditions:
	%%
	%% The above copyright notice and this permission notice shall be included in
	%% all copies or substantial portions of the Software.
	%%
	%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	%% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	%% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	%% DEALINGS IN THE SOFTWARE.

	%% @doc String Formatting for Erlang, inspired by Python 2.6
	%% (<a href="http://www.python.org/dev/peps/pep-3101/">PEP 3101</a>).
	%%
	-module(mochifmt).

	-author('bob@mochimedia.com').

	-export([convert_field/2, format/2, format_field/2,
	get_field/2, get_value/2]).

	-export([format/3, format_field/3, get_field/3,
	tokenize/1]).

	-export([bformat/2, bformat/3]).

	-export([f/2, f/3]).

	-record(conversion,
	{length, precision, ctype, align, fill_char, sign}).

	%% @spec tokenize(S::string()) -> tokens()
	%% @doc Tokenize a format string into mochifmt's internal format.
	tokenize(S) -> {?MODULE, tokenize(S, "", [])}.

	%% @spec convert_field(Arg, Conversion::conversion()) -> term()
	%% @doc Process Arg according to the given explicit conversion specifier.
	convert_field(Arg, "") -> Arg;
	convert_field(Arg, "r") -> repr(Arg);
	convert_field(Arg, "s") -> str(Arg).

	%% @spec get_value(Key::string(), Args::args()) -> term()
	%% @doc Get the Key from Args. If Args is a tuple then convert Key to
	%% an integer and get element(1 + Key, Args). If Args is a list and Key
	%% can be parsed as an integer then use lists:nth(1 + Key, Args),
	%% otherwise try and look for Key in Args as a proplist, converting
	%% Key to an atom or binary if necessary.
	get_value(Key, Args) when is_tuple(Args) ->
	element(1 + list_to_integer(Key), Args);
	get_value(Key, Args) when is_list(Args) ->
	try lists:nth(1 + list_to_integer(Key), Args) catch
	error:_ -> {_K, V} = proplist_lookup(Key, Args), V
	end.

	%% @spec get_field(Key::string(), Args) -> term()
	%% @doc Consecutively call get_value/2 on parts of Key delimited by ".",
	%% replacing Args with the result of the previous get_value. This
	%% is used to implement formats such as {0.0}.
	get_field(Key, Args) -> get_field(Key, Args, ?MODULE).

	%% @spec get_field(Key::string(), Args, Module) -> term()
	%% @doc Consecutively call Module:get_value/2 on parts of Key delimited by ".",
	%% replacing Args with the result of the previous get_value. This
	%% is used to implement formats such as {0.0}.
	get_field(Key, Args, Module) ->
	{Name, Next} = lists:splitwith(fun (C) -> C =/= $. end,
	Key),
	Res = mod_get_value(Name, Args, Module),
	case Next of
	"" -> Res;
	"." ++ S1 -> get_field(S1, Res, Module)
	end.

	mod_get_value(Name, Args, Module) ->
	try tuple_apply(Module, get_value, [Name, Args]) catch
	error:undef -> get_value(Name, Args)
	end.

	tuple_apply(Module, F, Args) when is_atom(Module) ->
	erlang:apply(Module, F, Args);
	tuple_apply(Module, F, Args)
	when is_tuple(Module), is_atom(element(1, Module)) ->
	erlang:apply(element(1, Module), F, Args ++ [Module]).

	%% @spec format(Format::string(), Args) -> iolist()
	%% @doc Format Args with Format.
	format(Format, Args) -> format(Format, Args, ?MODULE).

	%% @spec format(Format::string(), Args, Module) -> iolist()
	%% @doc Format Args with Format using Module.
	format({?MODULE, Parts}, Args, Module) ->
	format2(Parts, Args, Module, []);
	format(S, Args, Module) ->
	format(tokenize(S), Args, Module).

	%% @spec format_field(Arg, Format) -> iolist()
	%% @doc Format Arg with Format.
	format_field(Arg, Format) ->
	format_field(Arg, Format, ?MODULE).

	%% @spec format_field(Arg, Format, _Module) -> iolist()
	%% @doc Format Arg with Format.
	format_field(Arg, Format, _Module) ->
	F = default_ctype(Arg, parse_std_conversion(Format)),
	fix_padding(fix_sign(convert2(Arg, F), F), F).

	%% @spec f(Format::string(), Args) -> string()
	%% @doc Format Args with Format and return a string().
	f(Format, Args) -> f(Format, Args, ?MODULE).

	%% @spec f(Format::string(), Args, Module) -> string()
	%% @doc Format Args with Format using Module and return a string().
	f(Format, Args, Module) ->
	case lists:member(${, Format) of
	true -> binary_to_list(bformat(Format, Args, Module));
	false -> Format
	end.

	%% @spec bformat(Format::string(), Args) -> binary()
	%% @doc Format Args with Format and return a binary().
	bformat(Format, Args) ->
	iolist_to_binary(format(Format, Args)).

	%% @spec bformat(Format::string(), Args, Module) -> binary()
	%% @doc Format Args with Format using Module and return a binary().
	bformat(Format, Args, Module) ->
	iolist_to_binary(format(Format, Args, Module)).

	%% Internal API

	add_raw("", Acc) -> Acc;
	add_raw(S, Acc) -> [{raw, lists:reverse(S)} \| Acc].

	tokenize([], S, Acc) -> lists:reverse(add_raw(S, Acc));
	tokenize("{{" ++ Rest, S, Acc) ->
	tokenize(Rest, "{" ++ S, Acc);
	tokenize("{" ++ Rest, S, Acc) ->
	{Format, Rest1} = tokenize_format(Rest),
	tokenize(Rest1, "",
	[{format, make_format(Format)} \| add_raw(S, Acc)]);
	tokenize("}}" ++ Rest, S, Acc) ->
	tokenize(Rest, "}" ++ S, Acc);
	tokenize([C \| Rest], S, Acc) ->
	tokenize(Rest, [C \| S], Acc).

	tokenize_format(S) -> tokenize_format(S, 1, []).

	tokenize_format("}" ++ Rest, 1, Acc) ->
	{lists:reverse(Acc), Rest};
	tokenize_format("}" ++ Rest, N, Acc) ->
	tokenize_format(Rest, N - 1, "}" ++ Acc);
	tokenize_format("{" ++ Rest, N, Acc) ->
	tokenize_format(Rest, 1 + N, "{" ++ Acc);
	tokenize_format([C \| Rest], N, Acc) ->
	tokenize_format(Rest, N, [C \| Acc]).

	make_format(S) ->
	{Name0, Spec} = case lists:splitwith(fun (C) -> C =/= $:
	end,
	S)
	of
	{_, ""} -> {S, ""};
	{SN, ":" ++ SS} -> {SN, SS}
	end,
	{Name, Transform} = case lists:splitwith(fun (C) ->
	C =/= $!
	end,
	Name0)
	of
	{_, ""} -> {Name0, ""};
	{TN, "!" ++ TT} -> {TN, TT}
	end,
	{Name, Transform, Spec}.

	proplist_lookup(S, P) ->
	A = try list_to_existing_atom(S) catch
	error:_ -> make_ref()
	end,
	B = try list_to_binary(S) catch
	error:_ -> make_ref()
	end,
	proplist_lookup2({S, A, B}, P).

	proplist_lookup2({KS, KA, KB}, [{K, V} \| _])
	when KS =:= K orelse KA =:= K orelse KB =:= K ->
	{K, V};
	proplist_lookup2(Keys, [_ \| Rest]) ->
	proplist_lookup2(Keys, Rest).

	format2([], _Args, _Module, Acc) -> lists:reverse(Acc);
	format2([{raw, S} \| Rest], Args, Module, Acc) ->
	format2(Rest, Args, Module, [S \| Acc]);
	format2([{format, {Key, Convert, Format0}} \| Rest],
	Args, Module, Acc) ->
	Format = f(Format0, Args, Module),
	V = case Module of
	?MODULE ->
	V0 = get_field(Key, Args),
	V1 = convert_field(V0, Convert),
	format_field(V1, Format);
	_ ->
	V0 = try tuple_apply(Module, get_field, [Key, Args])
	catch
	error:undef -> get_field(Key, Args, Module)
	end,
	V1 = try tuple_apply(Module, convert_field,
	[V0, Convert])
	catch
	error:undef -> convert_field(V0, Convert)
	end,
	try tuple_apply(Module, format_field, [V1, Format])
	catch
	error:undef -> format_field(V1, Format, Module)
	end
	end,
	format2(Rest, Args, Module, [V \| Acc]).

	default_ctype(_Arg, C = #conversion{ctype = N})
	when N =/= undefined ->
	C;
	default_ctype(Arg, C) when is_integer(Arg) ->
	C#conversion{ctype = decimal};
	default_ctype(Arg, C) when is_float(Arg) ->
	C#conversion{ctype = general};
	default_ctype(_Arg, C) -> C#conversion{ctype = string}.

	fix_padding(Arg, #conversion{length = undefined}) ->
	Arg;
	fix_padding(Arg,
	F = #conversion{length = Length, fill_char = Fill0,
	align = Align0, ctype = Type}) ->
	Padding = Length - iolist_size(Arg),
	Fill = case Fill0 of
	undefined -> $\s;
	_ -> Fill0
	end,
	Align = case Align0 of
	undefined ->
	case Type of
	string -> left;
	_ -> right
	end;
	_ -> Align0
	end,
	case Padding > 0 of
	true -> do_padding(Arg, Padding, Fill, Align, F);
	false -> Arg
	end.

	do_padding(Arg, Padding, Fill, right, _F) ->
	[lists:duplicate(Padding, Fill), Arg];
	do_padding(Arg, Padding, Fill, center, _F) ->
	LPadding = lists:duplicate(Padding div 2, Fill),
	RPadding = case Padding band 1 of
	1 -> [Fill \| LPadding];
	_ -> LPadding
	end,
	[LPadding, Arg, RPadding];
	do_padding([$- \| Arg], Padding, Fill, sign_right, _F) ->
	[[$- \| lists:duplicate(Padding, Fill)], Arg];
	do_padding(Arg, Padding, Fill, sign_right,
	#conversion{sign = $-}) ->
	[lists:duplicate(Padding, Fill), Arg];
	do_padding([S \| Arg], Padding, Fill, sign_right,
	#conversion{sign = S}) ->
	[[S \| lists:duplicate(Padding, Fill)], Arg];
	do_padding(Arg, Padding, Fill, sign_right,
	#conversion{sign = undefined}) ->
	[lists:duplicate(Padding, Fill), Arg];
	do_padding(Arg, Padding, Fill, left, _F) ->
	[Arg \| lists:duplicate(Padding, Fill)].

	fix_sign(Arg, #conversion{sign = $+}) when Arg >= 0 ->
	[$+, Arg];
	fix_sign(Arg, #conversion{sign = $\s}) when Arg >= 0 ->
	[$\s, Arg];
	fix_sign(Arg, _F) -> Arg.

	ctype($%) -> percent;
	ctype($s) -> string;
	ctype($b) -> bin;
	ctype($o) -> oct;
	ctype($X) -> upper_hex;
	ctype($x) -> hex;
	ctype($c) -> char;
	ctype($d) -> decimal;
	ctype($g) -> general;
	ctype($f) -> fixed;
	ctype($e) -> exp.

	align($<) -> left;
	align($>) -> right;
	align($^) -> center;
	align($=) -> sign_right.

	convert2(Arg, F = #conversion{ctype = percent}) ->
	[convert2(1.0e+2 * Arg, F#conversion{ctype = fixed}),
	$%];
	convert2(Arg, #conversion{ctype = string}) -> str(Arg);
	convert2(Arg, #conversion{ctype = bin}) ->
	erlang:integer_to_list(Arg, 2);
	convert2(Arg, #conversion{ctype = oct}) ->
	erlang:integer_to_list(Arg, 8);
	convert2(Arg, #conversion{ctype = upper_hex}) ->
	erlang:integer_to_list(Arg, 16);
	convert2(Arg, #conversion{ctype = hex}) ->
	string:to_lower(erlang:integer_to_list(Arg, 16));
	convert2(Arg, #conversion{ctype = char})
	when Arg < 128 ->
	[Arg];
	convert2(Arg, #conversion{ctype = char}) ->
	xmerl_ucs:to_utf8(Arg);
	convert2(Arg, #conversion{ctype = decimal}) ->
	integer_to_list(Arg);
	convert2(Arg,
	#conversion{ctype = general, precision = undefined}) ->
	try mochinum:digits(Arg) catch
	error:undef -> io_lib:format("~g", [Arg])
	end;
	convert2(Arg,
	#conversion{ctype = fixed, precision = undefined}) ->
	io_lib:format("~f", [Arg]);
	convert2(Arg,
	#conversion{ctype = exp, precision = undefined}) ->
	io_lib:format("~e", [Arg]);
	convert2(Arg,
	#conversion{ctype = general, precision = P}) ->
	io_lib:format("~." ++ integer_to_list(P) ++ "g", [Arg]);
	convert2(Arg,
	#conversion{ctype = fixed, precision = P}) ->
	io_lib:format("~." ++ integer_to_list(P) ++ "f", [Arg]);
	convert2(Arg,
	#conversion{ctype = exp, precision = P}) ->
	io_lib:format("~." ++ integer_to_list(P) ++ "e", [Arg]).

	str(A) when is_atom(A) -> atom_to_list(A);
	str(I) when is_integer(I) -> integer_to_list(I);
	str(F) when is_float(F) ->
	try mochinum:digits(F) catch
	error:undef -> io_lib:format("~g", [F])
	end;
	str(L) when is_list(L) -> L;
	str(B) when is_binary(B) -> B;
	str(P) -> repr(P).

	repr(P) when is_float(P) ->
	try mochinum:digits(P) catch
	error:undef -> float_to_list(P)
	end;
	repr(P) -> io_lib:format("~p", [P]).

	parse_std_conversion(S) ->
	parse_std_conversion(S, #conversion{}).

	parse_std_conversion("", Acc) -> Acc;
	parse_std_conversion([Fill, Align \| Spec], Acc)
	when Align =:= $< orelse
	Align =:= $> orelse Align =:= $= orelse Align =:= $^ ->
	parse_std_conversion(Spec,
	Acc#conversion{fill_char = Fill,
	align = align(Align)});
	parse_std_conversion([Align \| Spec], Acc)
	when Align =:= $< orelse
	Align =:= $> orelse Align =:= $= orelse Align =:= $^ ->
	parse_std_conversion(Spec,
	Acc#conversion{align = align(Align)});
	parse_std_conversion([Sign \| Spec], Acc)
	when Sign =:= $+ orelse
	Sign =:= $- orelse Sign =:= $\s ->
	parse_std_conversion(Spec, Acc#conversion{sign = Sign});
	parse_std_conversion("0" ++ Spec, Acc) ->
	Align = case Acc#conversion.align of
	undefined -> sign_right;
	A -> A
	end,
	parse_std_conversion(Spec,
	Acc#conversion{fill_char = $0, align = Align});
	parse_std_conversion(Spec = [D \| _], Acc)
	when D >= $0 andalso D =< $9 ->
	{W, Spec1} = lists:splitwith(fun (C) ->
	C >= $0 andalso C =< $9
	end,
	Spec),
	parse_std_conversion(Spec1,
	Acc#conversion{length = list_to_integer(W)});
	parse_std_conversion([$. \| Spec], Acc) ->
	case lists:splitwith(fun (C) -> C >= $0 andalso C =< $9
	end,
	Spec)
	of
	{"", Spec1} -> parse_std_conversion(Spec1, Acc);
	{P, Spec1} ->
	parse_std_conversion(Spec1,
	Acc#conversion{precision = list_to_integer(P)})
	end;
	parse_std_conversion([Type], Acc) ->
	parse_std_conversion("",
	Acc#conversion{ctype = ctype(Type)}).

	%%
	%% Tests
	%%
	-ifdef(TEST).

	-include_lib("eunit/include/eunit.hrl").

	tokenize_test() ->
	{?MODULE, [{raw, "ABC"}]} = tokenize("ABC"),
	{?MODULE, [{format, {"0", "", ""}}]} = tokenize("{0}"),
	{?MODULE,
	[{raw, "ABC"}, {format, {"1", "", ""}}, {raw, "DEF"}]} =
	tokenize("ABC{1}DEF"),
	ok.

	format_test() ->
	<<" -4">> = bformat("{0:4}", [-4]),
	<<" 4">> = bformat("{0:4}", [4]),
	<<" 4">> = bformat("{0:{0}}", [4]),
	<<"4 ">> = bformat("{0:4}", ["4"]),
	<<"4 ">> = bformat("{0:{0}}", ["4"]),
	<<"1.2yoDEF">> = bformat("{2}{0}{1}{3}",
	{yo, "DE", 1.19999999999999995559, <<"F">>}),
	<<"cafebabe">> = bformat("{0:x}", {3405691582}),
	<<"CAFEBABE">> = bformat("{0:X}", {3405691582}),
	<<"CAFEBABE">> = bformat("{0:X}", {3405691582}),
	<<"755">> = bformat("{0:o}", {493}),
	<<"a">> = bformat("{0:c}", {97}),
	%% Horizontal ellipsis
	<<226, 128, 166>> = bformat("{0:c}", {8230}),
	<<"11">> = bformat("{0:b}", {3}),
	<<"11">> = bformat("{0:b}", [3]),
	<<"11">> = bformat("{three:b}", [{three, 3}]),
	<<"11">> = bformat("{three:b}", [{"three", 3}]),
	<<"11">> = bformat("{three:b}", [{<<"three">>, 3}]),
	<<"\"foo\"">> = bformat("{0!r}", {"foo"}),
	<<"2008-5-4">> = bformat("{0.0}-{0.1}-{0.2}",
	{{2008, 5, 4}}),
	<<"2008-05-04">> = bformat("{0.0:04}-{0.1:02}-{0.2:02}",
	{{2008, 5, 4}}),
	<<"foo6bar-6">> = bformat("foo{1}{0}-{1}", {bar, 6}),
	<<"-'atom test'-">> = bformat("-{arg!r}-",
	[{arg, 'atom test'}]),
	<<"2008-05-04">> =
	bformat("{0.0:0{1.0}}-{0.1:0{1.1}}-{0.2:0{1.2}}",
	{{2008, 5, 4}, {4, 2, 2}}),
	ok.

	std_test() ->
	M = mochifmt_std:new(),
	<<"01">> = bformat("{0}{1}", [0, 1], M),
	ok.

	records_test() ->
	M = mochifmt_records:new([{conversion,
	record_info(fields, conversion)}]),
	R = #conversion{length = long, precision = hard,
	sign = peace},
	long = mochifmt_records:get_value("length", R, M),
	hard = mochifmt_records:get_value("precision", R, M),
	peace = mochifmt_records:get_value("sign", R, M),
	<<"long hard">> = bformat("{length} {precision}", R, M),
	<<"long hard">> = bformat("{0.length} {0.precision}",
	[R], M),
	ok.

	-endif.