New options style

Author: kuenishi

README.md

@@ -67,6 +67,7 @@ OldHam = msgpack:pack(Spam, [{spec, old}]),
 ### `{allow_atom, none|pack}`
 
 Only in packing. Atoms are packed as binaries. Default value is `pack`.
+Otherwise, any term including atoms throws badarg.
 
 ### `{known_atoms, [atom()]}`
 
@@ -75,6 +76,8 @@ a binary is encoded as a binary. In unpacking, msgpacked binaries are
 decoded as atoms with `erlang:binary_to_existing_atom/2` with encoding
 `utf8`. Default value is an empty list.
 
+Even if `allow_atom` is `none`, known atoms are packed.
+
 ### `{unpack_str, as_binary|as_list}`
 
 A switch to choose decoded term style of `str` type when *unpacking*.

include/msgpack.hrl

@@ -1,7 +1,7 @@
 %%
 %% MessagePack for Erlang
 %%
-%% Copyright (C) 2009-2013 UENISHI Kota
+%% Copyright (C) 2009-2016 UENISHI Kota
 %%
 %%    Licensed under the Apache License, Version 2.0 (the "License");
 %%    you may not use this file except in compliance with the License.
@@ -45,10 +45,32 @@
 
 -include("msgpack.hrl").
 
-%% for export
--export_type([object/0, msgpack_map/0, options/0]).
+-export_type([object/0, msgpack_map/0, options/0, ext_packer/0, ext_unpacker/0]).
 -type object() :: msgpack_term().
--type options() :: msgpack_list_options().
+
+-type options() :: 
+        [{spec, new|old} |
+         {allow_atom, none|pack} |
+         {known_atoms, [atom()]} |
+         {unpack_str, as_binary|as_list} |
+         {validate_string, boolean()} |
+         {pack_str, from_binary|from_list|none} |
+         {map_format, map|jiffy|jsx} |
+         {ext, {msgpack:ext_packer(), msgpack:ext_unpacker()} | module()}].
+
+-type opt_record() :: ?OPTION{}.
+-export_type([opt_record/0]).
+
+%% @doc ext_packer that packs only tuples with length > 2
+-type ext_packer()   :: fun((tuple(), msgpack:options()) ->
+                                   {ok, {Type::byte(), Data::binary()}} |
+                                   {error, any()}).
+-type ext_unpacker() ::
+        fun((byte(), binary(), msgpack:options()) ->
+                   {ok, msgpack_term()} | {error, any()})
+      | fun((byte(), binary()) ->
+                   {ok, msgpack_term()} | {error, any()}).
+
 
 -spec term_to_binary(term()) -> binary().
 term_to_binary(Term) ->
@@ -114,39 +136,42 @@ unpack_stream(Bin, Opts0) when is_binary(Bin) ->
 unpack_stream(Other, _) -> {error, {badarg, Other}}.
 
 %% @private
--spec parse_options(msgpack:options()) -> msgpack_option().
+-spec parse_options(msgpack:options()) -> ?OPTION{}.
 
 parse_options(Opt) ->
     parse_options(Opt, ?OPTION{original_list=Opt}).
 
 %% @private
--spec parse_options(msgpack:options(), msgpack_option()) -> msgpack_option().
+-spec parse_options(msgpack:options(), ?OPTION{}) -> ?OPTION{}.
 parse_options([], Opt) -> Opt;
 
-parse_options([jsx|TL], Opt0) ->
-    Opt = Opt0?OPTION{interface=jsx,
-                      map_unpack_fun=msgpack_unpacker:map_unpacker(jsx)},
-    parse_options(TL, Opt);
-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; Type =:= map->
-    Opt = Opt0?OPTION{interface=Type,
-                      map_unpack_fun=msgpack_unpacker:map_unpacker(Type)},
-    parse_options(TL, Opt);
+parse_options([{spec, Spec}|T], Opt0) when Spec =:= new orelse Spec =:= old ->
+    parse_options(T, Opt0?OPTION{spec = Spec});
 
-parse_options([{allow_atom,Type}|TL], Opt0) ->
+parse_options([{allow_atom,Type}|T], Opt0) ->
     Opt = case Type of
               none -> Opt0?OPTION{allow_atom=none};
               pack -> Opt0?OPTION{allow_atom=pack}
           end,
-    parse_options(TL, Opt);
+    parse_options(T, Opt);
 
-parse_options([{enable_str,Bool}|TL], Opt0) ->
-    Opt = Opt0?OPTION{enable_str=Bool},
-    parse_options(TL, Opt);
+parse_options([{known_atoms, Atoms}|T], Opt0) when is_list(Atoms) ->
+    parse_options(T, Opt0?OPTION{known_atoms=Atoms});
+
+parse_options([{unpack_str, As}|T], Opt0) when As =:= as_binary orelse As =:= as_list ->
+    %% TODO Choose function here
+    parse_options(T, Opt0?OPTION{unpack_str=As});
+
+parse_options([{pack_str, From}|T], Opt)
+  when From =:= from_binary orelse From =:= from_list orelse From =:= none ->
+    %% TODO Choose function here
+    parse_options(T, Opt);
+
+parse_options([{map_format,Type}|T], Opt0)
+  when Type =:= jsx; Type =:= jiffy; Type =:= map ->
+    Opt = Opt0?OPTION{map_format=Type,
+                      map_unpack_fun=msgpack_unpacker:map_unpacker(Type)},
+    parse_options(T, Opt);
 
 parse_options([{ext, Module}|TL], Opt0) when is_atom(Module) ->
     Opt = Opt0?OPTION{ext_packer=fun Module:pack_ext/2,
@@ -201,9 +226,9 @@ test_data()->
 
 enable_str_test() ->
     ?assertEqual(<<167:8, (<<"saitama">>)/binary >>,
-                 msgpack:pack(<<"saitama">>, [{enable_str, false}])),
+                 msgpack:pack(<<"saitama">>, [{spec,old}])),
     ?assertEqual(<<196,7,115,97,105,116,97,109,97>>,
-                 msgpack:pack(<<"saitama">>, [{enable_str, true}])).
+                 msgpack:pack(<<"saitama">>, [{spec,new},{pack_str,from_binary}])).
 
 basic_test()->
     Tests = test_data(),
@@ -240,9 +265,9 @@ other_test()->
     ?assertEqual({error,incomplete},msgpack:unpack(<<>>)).
 
 error_test()->
-    ?assertEqual({error,{badarg, atom}}, msgpack:pack(atom)),
+    ?assertEqual({error,{badarg, atom}}, msgpack:pack(atom, [{allow_atom, none}])),
     Term = {"hoge", "hage", atom},
-    ?assertEqual({error,{badarg, Term}}, msgpack:pack(Term)).
+    ?assertEqual({error,{badarg, Term}}, msgpack:pack(Term, [{allow_atom, none}])).
 
 long_binary_test()->
     A = msgpack:pack(1),

src/msgpack.erl

@@ -0,0 +1,50 @@
+%%
+%% MessagePack for Erlang
+%%
+%% Copyright (C) 2009-2016 UENISHI Kota
+%%
+%%    Licensed under the Apache License, Version 2.0 (the "License");
+%%    you may not use this file except in compliance with the License.
+%%    You may obtain a copy of the License at
+%%
+%%        http://www.apache.org/licenses/LICENSE-2.0
+%%
+%%    Unless required by applicable law or agreed to in writing, software
+%%    distributed under the License is distributed on an "AS IS" BASIS,
+%%    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%%    See the License for the specific language governing permissions and
+%%    limitations under the License.
+%%
+
+-type msgpack_map_jsx() :: [{msgpack_term(), msgpack_term()}] | [{}].
+-type msgpack_map_jiffy() :: {[{msgpack_term(), msgpack_term()}]}.
+-type msgpack_map() :: msgpack_map_jsx() | msgpack_map_jiffy() | map().
+
+-type msgpack_map_unpacker() ::
+        fun((binary(), non_neg_integer(), msgpack:opt_record()) ->
+                   {msgpack_map(), binary()} | no_return() ).
+
+%% Erlang representation of msgpack data.
+-type msgpack_term() :: [msgpack_term()] | msgpack_map() |
+                        integer() | float() | boolean() | binary().
+
+-type format_type() :: jsx|jiffy|map.
+
+-define(DEFAULT_MAP_FORMAT, map).
+-define(DEFAULT_MAP_UNPACKER_FUN, fun msgpack_unpacker:unpack_map/3).
+
+-record(options_v4, {
+          spec = new :: new | old,
+          allow_atom = pack  :: none | pack, %% allows atom when packing
+          known_atoms = [] :: [atom()],
+          unpack_str = as_list :: as_binary | as_list,
+          validate_string = false :: boolean(),
+          pack_str = from_list :: from_binary | from_list | none,
+          map_format = ?DEFAULT_MAP_FORMAT :: format_type(),
+          map_unpack_fun = ?DEFAULT_MAP_UNPACKER_FUN :: msgpack_map_unpacker(),
+          ext_packer = undefined   :: msgpack:ext_packer()   | undefined,
+          ext_unpacker = undefined :: msgpack:ext_unpacker() | undefined,
+          original_list = []       :: msgpack:options()
+         }).
+
+-define(OPTION, #options_v4).

src/msgpack.hrl

@@ -24,8 +24,7 @@
 -include_lib("eunit/include/eunit.hrl").
 
 %% pack them all
--spec pack(msgpack:object(), msgpack_option()) -> binary().
-
+-spec pack(msgpack:object(), ?OPTION{}) -> binary().
 pack(I, _) when is_integer(I) andalso I < 0 ->
     pack_int(I);
 pack(I, _) when is_integer(I) ->
@@ -43,19 +42,26 @@ pack(Bin, Opt) when is_binary(Bin) ->
     handle_binary(Bin, Opt);
 
 pack(Atom, ?OPTION{allow_atom=pack} = Opt) when is_atom(Atom) ->
-    pack(erlang:atom_to_binary(Atom, unicode), Opt);
+    handle_binary(erlang:atom_to_binary(Atom, utf8), Opt);
+pack(Atom, ?OPTION{known_atoms=Atoms} = Opt) when is_atom(Atom) ->
+    case lists:member(Atom, Atoms) of
+        true ->
+            handle_binary(erlang:atom_to_binary(Atom, utf8), Opt);
+        false ->
+            handle_ext(Atom, Opt)
+    end;
 
 %% jiffy interface
-pack({Map}, Opt = ?OPTION{interface=jiffy}) when is_list(Map) ->
+pack({Map}, Opt = ?OPTION{map_format=jiffy}) when is_list(Map) ->
     pack_map(Map, Opt);
 
 %% jsx interface
-pack(Map, Opt = ?OPTION{interface=jsx}) when Map =:= [{}]->
+pack(Map, Opt = ?OPTION{map_format=jsx}) when Map =:= [{}]->
     pack_map([], Opt);
-pack([{_,_}|_] = Map, Opt = ?OPTION{interface=jsx}) ->
+pack([{_,_}|_] = Map, Opt = ?OPTION{map_format=jsx}) ->
     pack_map(Map, Opt);
 
-pack(List, ?OPTION{enable_str=true}=Opt)  when is_list(List) ->
+pack(List, ?OPTION{spec=new, pack_str=from_list}=Opt)  when is_list(List) ->
     try
         case lists:all(fun is_integer/1, List) of
             true ->
@@ -80,14 +86,14 @@ pack(List, Opt)  when is_list(List) ->
 pack(Other, Opt) ->
     handle_ext(Other, Opt).
 
-handle_binary(Bin, Opt) ->
-    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)
-    end.
+handle_binary(Bin, ?OPTION{spec=old}) ->
+    pack_raw(Bin);
+handle_binary(Bin, ?OPTION{spec=new, pack_str=from_list}) ->
+    pack_raw2(Bin);
+handle_binary(Bin, ?OPTION{spec=new, pack_str=from_binary} = Opt) ->
+    pack_string(unicode:characters_to_list(Bin), Opt);
+handle_binary(Bin, ?OPTION{spec=new}) ->
+    pack_raw2(Bin).
 
 %% %% map interface
 handle_ext(Map, Opt) when is_map(Map) ->
@@ -187,7 +193,7 @@ pack_raw2(Bin) ->
 %% @doc String MAY be unicode. Or may be EUC-JP, SJIS, UTF-1024 or anything.
 %% EVERY implementation must show its binary length just after type indicator
 %% to skip the damn string if its unreadable.
--spec pack_string(list(), msgpack_option()) -> binary() | {error, atom()}.
+-spec pack_string(list(), ?OPTION{}) -> binary() | {error, atom()}.
 pack_string(String, _Opt) ->
     case unicode:characters_to_binary(String) of
         {error, _Bin, _} -> {error, broken_unicode};
@@ -207,7 +213,7 @@ pack_string(String, _Opt) ->
             end
     end.
 
--spec pack_array([msgpack:object()], msgpack_option()) -> binary() | no_return().
+-spec pack_array([msgpack:object()], ?OPTION{}) -> binary() | no_return().
 pack_array([], _) ->
     << 2#1001:4, 0:4/integer-unit:1 >>;
 
@@ -299,7 +305,7 @@ pack_array(L, Opt) ->
             throw({badarg, L})
     end.
 
--spec pack_map(msgpack:msgpack_map(), msgpack_option()) -> binary() | no_return().
+-spec pack_map(msgpack:msgpack_map(), ?OPTION{}) -> binary() | no_return().
 pack_map([{Ka, Va}], Opt)->
     << 2#1000:4, 1:4/integer-unit:1,
        (pack(Ka, Opt))/binary, (pack(Va, Opt))/binary >>;
@@ -337,7 +343,7 @@ pack_map(M, Opt)->
             throw({badarg, M})
     end.
 
--spec pack_ext(any(), msgpack_ext_packer(), msgpack:options()) -> {ok, binary()} | {error, any()}.
+-spec pack_ext(any(), msgpack:ext_packer(), msgpack:options()) -> {ok, binary()} | {error, any()}.
 pack_ext(Any, Packer, Opt) ->
     case Packer(Any, Opt) of
         {ok, {Type, Data}} when -16#80 =< Type andalso Type =< 16#7F ->