added 17.0 map. next: compatibility code with rebar.config.script

kuenishi · kuenishi · commit 3a2009552672 · 2014-04-10T02:57:44.000+09:00
diff --git a/README.md b/README.md
@@ -46,6 +46,21 @@ Opt = [{enable_str, true}]
 There are several options for `msgpack:pack/2` and `msgpack:unpack/2` .
 See `msgpack:options()` in `msgpack.hrl`.
 
+## Map Style
+
+Since Erlang/OTP 17.0
+
+```erlang
+msgpack:pack(#{ <<"key">> => <<"value">> }, [{format, map}]).
+```
+
+Or use old jiffy/jsx style
+
+```erlang
+msgpack:pack({[{<<"key">>, <<"value">>}]}, [{format, jiffy}]),
+msgpack:pack([{<<"key">>, <<"value">>}], [{format, jsx}]).
+```
+
 ## Ext type
 
 Now msgpack-erlang supports ext type. Now you can serialize everything
diff --git a/include/msgpack.hrl b/include/msgpack.hrl
@@ -21,7 +21,8 @@
 
 -type msgpack_map_jiffy() :: {[{msgpack_term(), msgpack_term()}]}.
 
--type msgpack_map() :: msgpack_map_jsx() | msgpack_map_jiffy().
+-type msgpack_map() :: msgpack_map_jsx() | msgpack_map_jiffy()
+                     | map().
 
 -type msgpack_map_unpacker() ::
         fun((binary(), non_neg_integer(), msgpack_map(), msgpack_option()) ->
@@ -41,8 +42,10 @@
       | fun((byte(), binary()) ->
                    {ok, msgpack_term()} | {error, any()}).
 
+-type format_type() :: jsx|jiffy|map.
+
 -type msgpack_list_options() :: [
-                                 {format, jsx|jiffy} |
+                                 {format, format_type()} |
                                  jsx | jiffy |
                                  {allow_atom, none|pack} |
                                  {enable_str, boolean()} |
@@ -51,14 +54,26 @@
 
 -record(options_v1, {
           interface = jiffy :: jiffy | jsx,
-          map_unpack_fun = fun msgpack_unpacker:unpack_map_jiffy/4 ::
+          map_unpack_fun = fun msgpack_unpacker:unpack_map_jiffy/3 ::
                                  msgpack_map_unpacker(),
           impl = erlang     :: erlang | nif
          }).
 
 -record(options_v2, {
           interface = jiffy :: jiffy | jsx,
-          map_unpack_fun = fun msgpack_unpacker:unpack_map_jiffy/4 ::
+          map_unpack_fun = fun msgpack_unpacker:unpack_map_jiffy/3 ::
+                                 msgpack_map_unpacker(),
+          impl = erlang      :: erlang | nif,
+          allow_atom = none  :: none | pack, %% allows atom when packing
+          enable_str = false :: boolean(), %% true for new spec
+          ext_packer = undefined   :: msgpack_ext_packer()   | undefined,
+          ext_unpacker = undefined :: msgpack_ext_unpacker() | undefined,
+          original_list = []       :: msgpack_list_options()
+         }).
+
+-record(options_v3, {
+          interface = map :: format_type(),
+          map_unpack_fun = fun msgpack_unpacker:unpack_map/3 ::
                                  msgpack_map_unpacker(),
           impl = erlang      :: erlang | nif,
           allow_atom = none  :: none | pack, %% allows atom when packing
@@ -68,5 +83,5 @@
           original_list = []       :: msgpack_list_options()
          }).
 
--define(OPTION, #options_v2).
--type msgpack_option() :: #options_v2{}.
+-define(OPTION, #options_v3).
+-type msgpack_option() :: #options_v3{}.
diff --git a/src/msgpack.erl b/src/msgpack.erl
@@ -31,6 +31,8 @@
 %%     <tr><td> binary()     </td><td> fix_raw/raw16/raw32                                                     </td></tr>
 %%     <tr><td> list()       </td><td> fix_array/array16/array32                                               </td></tr>
 %%     <tr><td> {proplist()} </td><td> fix_map/map16/map32                                                     </td></tr>
+%%     <tr><td> [{term(),term{}]|[{}] </td><td> fix_map/map16/map32                                                     </td></tr>
+%%     <tr><td> map()        </td><td> fix_map/map16/map32                                                     </td></tr>
 %%   </table>
 %% @end
 
@@ -113,11 +115,14 @@ unpack_stream(Other, _) -> {error, {badarg, Other}}.
 
 %% @private
 -spec parse_options(msgpack:options()) -> msgpack_option().
-parse_options(Opt) -> parse_options(Opt, ?OPTION{original_list=Opt}).
+
+parse_options(Opt) ->
+    parse_options(Opt, ?OPTION{original_list=Opt}).
 
 %% @private
 -spec parse_options(msgpack:options(), msgpack_option()) -> msgpack_option().
 parse_options([], Opt) -> Opt;
+
 parse_options([jsx|TL], Opt0) ->
     Opt = Opt0?OPTION{interface=jsx,
                       map_unpack_fun=msgpack_unpacker:map_unpacker(jsx)},
@@ -126,19 +131,23 @@ parse_options([jiffy|TL], Opt0) ->
     Opt = Opt0?OPTION{interface=jiffy,
                       map_unpack_fun=msgpack_unpacker:map_unpacker(jiffy)},
     parse_options(TL, Opt);
-parse_options([{format,Type}|TL], Opt0) when Type =:= jsx; Type =:= jiffy ->
+parse_options([{format,Type}|TL], Opt0)
+  when Type =:= jsx; Type =:= jiffy; Type =:= map->
     Opt = Opt0?OPTION{interface=Type,
                       map_unpack_fun=msgpack_unpacker:map_unpacker(Type)},
     parse_options(TL, Opt);
+
 parse_options([{allow_atom,Type}|TL], Opt0) ->
     Opt = case Type of
               none -> Opt0?OPTION{allow_atom=none};
               pack -> Opt0?OPTION{allow_atom=pack}
           end,
     parse_options(TL, Opt);
+
 parse_options([{enable_str,Bool}|TL], Opt0) ->
     Opt = Opt0?OPTION{enable_str=Bool},
     parse_options(TL, Opt);
+
 parse_options([{ext, Module}|TL], Opt0) when is_atom(Module) ->
     Opt = Opt0?OPTION{ext_packer=fun Module:pack_ext/2,
                       ext_unpacker=fun Module:unpack_ext/3},
@@ -149,6 +158,7 @@ parse_options([{ext, {Packer,Unpacker}}|TL], Opt0) when
     Opt = Opt0?OPTION{ext_packer=Packer, ext_unpacker=Unpacker},
     parse_options(TL, Opt).
 
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% unit tests
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/src/msgpack_packer.erl b/src/msgpack_packer.erl
@@ -41,6 +41,8 @@ pack(true, _) ->
 
 pack(Bin, Opt) when is_binary(Bin) ->
     case Opt of
+        #options_v3{enable_str=true} = Opt -> pack_raw2(Bin);
+        #options_v3{enable_str=false} = Opt -> pack_raw(Bin);
         #options_v2{enable_str=true} = Opt -> pack_raw2(Bin);
         #options_v2{enable_str=false} = Opt -> pack_raw(Bin);
         #options_v1{} = Opt -> pack_raw(Bin)
@@ -49,6 +51,10 @@ pack(Bin, Opt) when is_binary(Bin) ->
 pack(Atom, #options_v2{allow_atom=pack} = Opt) when is_atom(Atom) ->
     pack(erlang:atom_to_binary(Atom, unicode), Opt);
 
+%% map interface
+pack(Map, Opt = ?OPTION{interface=map}) when is_map(Map) ->
+    pack_map(maps:to_list(Map), Opt);
+
 %% jiffy interface
 pack({Map}, Opt = ?OPTION{interface=jiffy}) when is_list(Map) ->
     pack_map(Map, Opt);
@@ -59,7 +65,7 @@ pack(Map, Opt = ?OPTION{interface=jsx}) when Map =:= [{}]->
 pack([{_,_}|_] = Map, Opt = ?OPTION{interface=jsx}) ->
     pack_map(Map, Opt);
 
-pack(List, #options_v2{enable_str=true}=Opt)  when is_list(List) ->
+pack(List, ?OPTION{enable_str=true}=Opt)  when is_list(List) ->
     try
         case lists:all(fun is_integer/1, List) of
             true ->
diff --git a/src/msgpack_unpacker.erl b/src/msgpack_unpacker.erl
@@ -23,7 +23,7 @@
 -include("msgpack.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
--export([unpack_map_jiffy/4, unpack_map_jsx/4]).
+-export([unpack_map/3, unpack_map_jiffy/3, unpack_map_jsx/3]).
 
 %% unpack them all
 -spec unpack_stream(Bin::binary(), msgpack_option()) -> {msgpack:object(), binary()} | no_return().
@@ -94,14 +94,14 @@ unpack_stream(<<16#DD, L:32/big-unsigned-integer-unit:1, Rest/binary>>, Opt) ->
 %% Maps
 unpack_stream(<<2#1000:4, L:4, Rest/binary>>, Opt) ->
     Unpacker = Opt?OPTION.map_unpack_fun,
-    Unpacker(Rest, L, [], Opt);
+    Unpacker(Rest, L, Opt);
 unpack_stream(<<16#DE, L:16/big-unsigned-integer-unit:1, Rest/binary>>, Opt) ->
     Unpacker = Opt?OPTION.map_unpack_fun,
-    Unpacker(Rest, L, [], Opt);
+    Unpacker(Rest, L, Opt);
 
 unpack_stream(<<16#DF, L:32/big-unsigned-integer-unit:1, Rest/binary>>, Opt) ->
     Unpacker = Opt?OPTION.map_unpack_fun,
-    Unpacker(Rest, L, [], Opt);
+    Unpacker(Rest, L, Opt);
 
 %% Tag-encoded lengths (kept last, for speed)
 %% positive int
@@ -166,34 +166,50 @@ unpack_array(Bin, Len, Acc, Opt) ->
     {Term, Rest} = unpack_stream(Bin, Opt),
     unpack_array(Rest, Len-1, [Term|Acc], Opt).
 
+map_unpacker(map) ->
+    fun ?MODULE:unpack_map/3;
 map_unpacker(jiffy) ->
-    fun ?MODULE:unpack_map_jiffy/4;
+    fun ?MODULE:unpack_map_jiffy/3;
 map_unpacker(jsx) ->
-    fun ?MODULE:unpack_map_jsx/4.
+    fun ?MODULE:unpack_map_jsx/3.
 
 
+-spec unpack_map(binary(), non_neg_integer(), msgpack_option()) ->
+                        {map(), binary()} | no_return().
+unpack_map(Bin, Len, Opt) ->
+    {Map, Rest} = unpack_map_as_proplist(Bin, Len, [], Opt),
+    {maps:from_list(Map), Rest}.
+%%     unpack_map(Bin, Len, #{}, Opt).
+
+%% unpack_map(Bin, Len, Acc, _) -> {Acc, Bin};
+%% unpack_map(Bin, Len, Acc, Opt) ->
+%%     {Key, Rest} = unpack_stream(Bin, Opt),
+%%     {Value, Rest2} = unpack_stream(Rest, Opt),
+%%     unpack_map(Rest2, Len-1, maps:put(Key, Value, Acc), Opt).
+
 %% Users SHOULD NOT send too long list: this uses lists:reverse/1
--spec unpack_map_jiffy(binary(), non_neg_integer(),
-                       msgpack:msgpack_map(), msgpack_option()) ->
-                              {msgpack:msgpack_map(), binary()} | no_return().
-unpack_map_jiffy(Bin, 0,   Acc, _) ->
-    {{lists:reverse(Acc)}, Bin};
-unpack_map_jiffy(Bin, Len, Acc, Opt) ->
-    {Key, Rest} = unpack_stream(Bin, Opt),
-    {Value, Rest2} = unpack_stream(Rest, Opt),
-    unpack_map_jiffy(Rest2, Len-1, [{Key,Value}|Acc], Opt).
-
--spec unpack_map_jsx(binary(), non_neg_integer(),
-                     msgpack:msgpack_map(), msgpack_option()) ->
-                            {msgpack:msgpack_map(), binary()} | no_return().
-unpack_map_jsx(Bin, 0, [], _) ->
-    {[{}], Bin};
-unpack_map_jsx(Bin, 0,   Acc, _) ->
+-spec unpack_map_jiffy(binary(), non_neg_integer(), msgpack_option()) ->
+                              {msgpack:msgpack_map_jiffy(), binary()} | no_return().
+unpack_map_jiffy(Bin, Len, Opt) ->
+    {Map, Rest} = unpack_map_as_proplist(Bin, Len, [], Opt),
+    {{Map}, Rest}.
+
+-spec unpack_map_jsx(binary(), non_neg_integer(), msgpack_option()) ->
+                            {msgpack:msgpack_map_jsx(), binary()} | no_return().
+unpack_map_jsx(Bin, Len, Opt) ->
+    case unpack_map_as_proplist(Bin, Len, [], Opt) of
+        {[], Rest} -> {[{}], Rest};
+        {Map, Rest} -> {Map, Rest}
+    end.
+
+-spec unpack_map_as_proplist(binary(), non_neg_integer(), proplists:proplist(), msgpack_option()) ->
+                                    {proplists:proplist(), binary()} | no_return().
+unpack_map_as_proplist(Bin, 0, Acc, _) ->
     {lists:reverse(Acc), Bin};
-unpack_map_jsx(Bin, Len, Acc, Opt) ->
+unpack_map_as_proplist(Bin, Len, Acc, Opt) ->
     {Key, Rest} = unpack_stream(Bin, Opt),
     {Value, Rest2} = unpack_stream(Rest, Opt),
-    unpack_map_jsx(Rest2, Len-1, [{Key,Value}|Acc], Opt).
+    unpack_map_as_proplist(Rest2, Len-1, [{Key,Value}|Acc], Opt).
 
 unpack_string_or_raw(V, ?OPTION{enable_str=true} = _Opt, Rest) ->
     {unpack_string(V), Rest};
diff --git a/test/msgpack_test.erl b/test/msgpack_test.erl
@@ -25,7 +25,7 @@
 
 -ifdef(DO_MSGPACK_CROSSLANG_TEST).
 
-test_data_jsx()->
+test_data() ->
     [true, false, nil,
      0, 1, 2, 123, 512, 1230, 678908, 16#FFFFFFFFFF,
      -1, -23, -512, -1230, -567898, -16#FFFFFFFFFF,
@@ -35,23 +35,16 @@ test_data_jsx()->
      <<"hoasfdafdas][">>,
      [0,42, <<"sum">>, [1,2]], [1,42, nil, [3]],
      -234, -40000, -16#10000000, -16#100000000,
-     42,
-     [{}], {hoge}
-    ].
+     42].
+
+test_data_jsx()->
+    test_data() ++ [[{}], {hoge}].
 
 test_data_jiffy()->
-    [true, false, nil,
-     0, 1, 2, 123, 512, 1230, 678908, 16#FFFFFFFFFF,
-     -1, -23, -512, -1230, -567898, -16#FFFFFFFFFF,
-     123.123, -234.4355, 1.0e-34, 1.0e64,
-     [23, 234, 0.23],
-     <<"hogehoge">>, <<"243546rf7g68h798j", 0, 23, 255>>,
-     <<"hoasfdafdas][">>,
-     [0,42, <<"sum">>, [1,2]], [1,42, nil, [3]],
-     -234, -40000, -16#10000000, -16#100000000,
-     42,
-     {[]}, {hoge}
-    ].
+    test_data() ++ [ {[]}, {hoge} ].
+
+test_data_map()->
+    test_data() ++ [ #{}, {hoge} ].
 
 compare_all([], [])-> ok;
 compare_all([],  R)-> {toomuchrhs, R};
@@ -69,6 +62,10 @@ port_receive(Port, Acc) ->
     after 1000 -> Acc
     end.
 
+port_map_test()->
+    Tests = test_data_map(),
+    ?assertEqual({[Tests],<<>>}, msgpack:unpack(msgpack:pack([Tests], [{format,map}]), [{format,map}])),
+
 port_jiffy_test()->
     Tests = test_data_jiffy(),
     ?assertEqual({[Tests],<<>>}, msgpack:unpack(msgpack:pack([Tests], [{format,jiffy}]), [{format,jiffy}])),
@@ -77,7 +74,7 @@ port_jiffy_test()->
                                                 %    true = port_command(Port, msgpack:pack(Tests)),
                                                 %    ?assertEqual({Tests, <<>>}, msgpack:unpack(port_receive(Port))),
                                                 %    port_close(Port).
-                 ok.
+    ok.
 
 
 port_jsx_test()->
@@ -121,6 +118,8 @@ issue_jsx_5_test() ->
     Bin0 = <<130,196,4,116,121,112,101,196,7,119,111,114,107,101,114,115,
              196,4,100,97,116,97,145,130,196,8,119,111,114,107,101,114,105,100,
              196,5,115,116,100,46,49,196,5,115,108,111,116,115,160>>,
+    ?debugFmt("~w", [binary_to_list(Bin0)]),
+    ?debugFmt("~w", [binary_to_list(Encoded)]),
     ?assertEqual(Bin0, Encoded),
 
     {ok, Decoded} = msgpack:unpack(Bin0, [{format,jsx}, {enable_str,true}]),
