fix blocktrans unparser tests.

src/erlydtl_unparser.erl

@@ -13,7 +13,7 @@ unparse([{'autoescape', OnOrOff, Contents}|Rest], Acc) ->
 unparse([{'block', Identifier, Contents}|Rest], Acc) ->
     unparse(Rest, [["{% block ", unparse_identifier(Identifier), " %}", unparse(Contents), "{% endblock %}"]|Acc]);
 unparse([{'blocktrans', Args, Contents, undefined}|Rest], Acc) ->
-    unparse(Rest, [["{% blocktrans ", unparse_blocktrans_args(Args), "%}", unparse(Contents), "{% endblocktrans %}"]|Acc]);
+    unparse(Rest, [["{% blocktrans ", unparse_blocktrans_args(Args), " %}", unparse(Contents), "{% endblocktrans %}"]|Acc]);
 unparse([{'blocktrans', Args, Contents, PluralContents}|Rest], Acc) ->
     unparse(Rest, [["{% blocktrans ", unparse_blocktrans_args(Args), " %}",
                     unparse(Contents),
@@ -184,11 +184,9 @@ unparse_args(Args) ->
     unparse_args(Args, []).
 
 unparse_args([], Acc) ->
-    lists:reverse(Acc);
-unparse_args([{{identifier, _, Name}, Value}], Acc) ->
-    unparse_args([], [[atom_to_list(Name), "=", unparse_value(Value)]|Acc]);
-unparse_args([{{identifier, _, Name}, Value}|Rest], Acc) ->
-    unparse_args(Rest, lists:reverse([[atom_to_list(Name), "=", unparse_value(Value)], " "], Acc)).
+    collect_args_acc(Acc);
+unparse_args([{{identifier, _, Name}, Value}|Args], Acc) ->
+    unparse_args(Args, [[atom_to_list(Name), "=", unparse_value(Value)]|Acc]).
 
 unparse_cycle_compat_names(Names) ->
     unparse_cycle_compat_names(Names, []).
@@ -203,6 +201,8 @@ unparse_cycle_compat_names([{identifier, _, Name}|Rest], Acc) ->
 unparse_blocktrans_args(Args) ->
     unparse_blocktrans_args(Args, []).
 
+unparse_blocktrans_args([], Acc) ->
+    collect_args_acc(Acc);
 unparse_blocktrans_args([{args, WithArgs}|Args], Acc) ->
     unparse_blocktrans_args(
       Args, [["with ", unparse_args(WithArgs)]|Acc]);
@@ -214,6 +214,7 @@ unparse_blocktrans_args([{context, Context}|Args], Acc) ->
       Args, [["context ", unparse_value(Context)]|Acc]);
 unparse_blocktrans_args([trimmed|Args], Acc) ->
     unparse_blocktrans_args(
-      Args, ["trimmed"|Acc]);
-unparse_blocktrans_args([], Acc) ->
-    lists:reverse(Acc).
+      Args, ["trimmed"|Acc]).
+
+collect_args_acc(Acc) ->
+    lists:flatten(string:join(lists:reverse(Acc), " ")).

test/erlydtl_test_defs.erl

@@ -1450,7 +1450,7 @@ all_test_defs() ->
           errors = [error_info([{{1,31}, erlydtl_parser, ["syntax error before: ","'.'"]}])]
          },
        {"blocktrans runtime",
-        <<"{% blocktrans with v1=foo%}Hello, {{ name }}! See {{v1}}.{%endblocktrans%}">>,
+        <<"{%blocktrans with v1=foo%}Hello, {{ name }}! See {{v1}}.{%endblocktrans%}">>,
         [{name, "Mr. President"}, {foo, <<"rubber-duck">>}],
         [{translation_fun, fun("Hello, {{ name }}! See {{ v1 }}.") -> <<"Guten tag, {{name}}! Sehen {{    v1   }}.">> end}],
         [], <<"Guten tag, Mr. President! Sehen rubber-duck.">>}

test/sources_parser_tests.erl

@@ -88,16 +88,31 @@ test_unparser_fun({Name, Tpl}) ->
                    %% take input Tpl value, parse it, "unparse" it, then parse it again.
                    %% both parsed values should be equvialent, even if the source versions
                    %% are not an exact match (there can be whitespace differences)
-                   {ok, Dpt} = erlydtl_compiler:do_parse_template(
-                                 Tpl, #dtl_context{}),
-                   Unparsed = erlydtl_unparser:unparse(Dpt),
-                   {ok, DptU} = erlydtl_compiler:do_parse_template(
-                                 Unparsed, #dtl_context{}),
-                   compare_tree(Dpt, DptU)
+                   case erlydtl_compiler:do_parse_template(
+                          Tpl, #dtl_context{}) of
+                       {ok, Dpt} ->
+                           Unparsed = erlydtl_unparser:unparse(Dpt),
+                           case erlydtl_compiler:do_parse_template(
+                                  Unparsed, #dtl_context{}) of
+                               {ok, DptU} ->
+                                   case catch compare_tree(Dpt, DptU) of
+                                       ok -> ok;
+                                       Err -> throw({compare_failed, Err, {test_ast, Dpt}, {unparsed, {source, Unparsed}, {ast, DptU}}})
+                                   end;
+                               Err ->
+                                   throw({unparsed_source, Err})
+                           end;
+                       Err ->
+                           throw({test_source, Err})
+                   end
            end}.
 
 unparser_test_defs() ->
-    [{"comment tag", <<"here it is: {# this is my comment #} <-- it was right there.">>}
+    [{"comment tag", <<"here it is: {# this is my comment #} <-- it was right there.">>},
+     {"blocktrans plain", <<"{% blocktrans %}foo bar{% endblocktrans %}">>},
+     {"blocktrans trimmed", <<"{% blocktrans trimmed %}\n foo \n   bar \n\n{% endblocktrans %}">>},
+     {"blocktrans with args", <<"{% blocktrans with var1=foo var2=bar count c=d %}blarg{% endblocktrans %}">>},
+     {"blocktrans with all", <<"{% blocktrans with var1=foo var2=bar trimmed context 'baz' count c=d %}blarg{% endblocktrans %}">>}
     ].
 
 
@@ -114,9 +129,13 @@ compare_token({'autoescape', OnOrOff1, Contents1}, {'autoescape', OnOrOff2, Cont
 compare_token({'block', Identifier1, Contents1}, {'block', Identifier2, Contents2}) ->
     compare_identifier(Identifier1, Identifier2),
     compare_tree(Contents1, Contents2);
-compare_token({'blocktrans', Args1, Contents1}, {'blocktrans', Args2, Contents2}) ->
-    compare_args(Args1, Args2),
-    compare_tree(Contents1, Contents2);
+compare_token({'blocktrans', Args1, Contents1, Plural1}, {'blocktrans', Args2, Contents2, Plural2}) ->
+    compare_blocktrans_args(Args1, Args2),
+    compare_tree(Contents1, Contents2),
+    case {Plural1, Plural2} of
+        {undefined, undefined} -> ok;
+        _ -> compare_tree(Plural1, Plural2)
+    end;
 compare_token({'call', Identifier1}, {'call', Identifier2}) ->
     compare_identifier(Identifier1, Identifier2);
 compare_token({'call', Identifier1, With1}, {'call', Identifier2, With2}) ->
@@ -203,14 +222,34 @@ compare_value({'attribute', {Variable1, Identifier1}}, {'attribute', {Variable2,
 compare_value({'variable', Identifier1}, {'variable', Identifier2}) ->
     compare_identifier(Identifier1, Identifier2).
 
-compare_args(Args1, Args2) ->
+compare_args(Args1, Args2) when length(Args1) =:= length(Args2) ->
     [compare_arg(A1, A2)
      || {A1, A2} <- lists:zip(Args1, Args2)].
 
+compare_arg(Arg, Arg) when is_atom(Arg) -> ok;
 compare_arg({{identifier, _, Name1}, Value1}, {{identifier, _, Name2}, Value2}) ->
     ?assertEqual(Name1, Name2),
     compare_value(Value1, Value2).
 
+compare_blocktrans_args([], []) -> ok;
+compare_blocktrans_args([{args, WithArgs1}|Args1], Args2) ->
+    {value, {args, WithArgs2}, Args3} = lists:keytake(args, 1, Args2),
+    compare_args(WithArgs1, WithArgs2),
+    compare_blocktrans_args(Args1, Args3);
+compare_blocktrans_args([{count, Count1}|Args1], Args2) ->
+    {value, {count, Count2}, Args3} = lists:keytake(count, 1, Args2),
+    compare_arg(Count1, Count2),
+    compare_blocktrans_args(Args1, Args3);
+compare_blocktrans_args([{context, Context1}|Args1], Args2) ->
+    {value, {context, Context2}, Args3} = lists:keytake(context, 1, Args2),
+    compare_value(Context1, Context2),
+    compare_blocktrans_args(Args1, Args3);
+compare_blocktrans_args([trimmed|Args1], Args2) ->
+    Args3 = Args2 -- [trimmed],
+    if Args2 =/= Args3 ->
+            compare_blocktrans_args(Args1, Args3)
+    end.
+
 compare_cycle_compat_names(Names1, Names2) ->
     [compare_identifier(N1, N2)
      || {N1, N2} <- lists:zip(Names1, Names2)].