395 lines
12 KiB
Bash
395 lines
12 KiB
Bash
|
#!/usr/bin/escript
|
||
|
|
%% -*- erlang -*-
|
||
|
|
%%! -pa ebin
|
||
|
|
|
||
|
|
-record(state, {run_hooks = dict:new(),
|
||
|
|
run_fold_hooks = dict:new(),
|
||
|
|
hooked_funs = dict:new(),
|
||
|
|
mfas = dict:new(),
|
||
|
|
specs = dict:new(),
|
||
|
|
module :: module(),
|
||
|
|
file :: filename:filename()}).
|
||
|
|
|
||
|
|
main([Dir]) ->
|
||
|
|
State =
|
||
|
|
filelib:fold_files(
|
||
|
|
Dir, ".+\.[eh]rl\$", false,
|
||
|
|
fun(FileIn, Res) ->
|
||
|
|
case get_forms(FileIn) of
|
||
|
|
{ok, Forms} ->
|
||
|
|
Tree = erl_syntax:form_list(Forms),
|
||
|
|
Mod = list_to_atom(filename:rootname(filename:basename(FileIn))),
|
||
|
|
Acc0 = analyze_form(Tree, Res#state{module = Mod, file = FileIn}),
|
||
|
|
erl_syntax_lib:fold(
|
||
|
|
fun(Form, Acc) ->
|
||
|
|
case erl_syntax:type(Form) of
|
||
|
|
application ->
|
||
|
|
case erl_syntax_lib:analyze_application(Form) of
|
||
|
|
{ejabberd_hooks, {run, N}}
|
||
|
|
when N == 2; N == 3 ->
|
||
|
|
analyze_run_hook(Form, Acc);
|
||
|
|
{ejabberd_hooks, {run_fold, N}}
|
||
|
|
when N == 3; N == 4 ->
|
||
|
|
analyze_run_fold_hook(Form, Acc);
|
||
|
|
{ejabberd_hooks, {add, N}}
|
||
|
|
when N == 4; N == 5 ->
|
||
|
|
analyze_run_fun(Form, Acc);
|
||
|
|
{gen_iq_handler, {add_iq_handler, 6}} ->
|
||
|
|
analyze_iq_handler(Form, Acc);
|
||
|
|
_ ->
|
||
|
|
Acc
|
||
|
|
end;
|
||
|
|
attribute ->
|
||
|
|
case catch erl_syntax_lib:analyze_attribute(Form) of
|
||
|
|
{spec, _} ->
|
||
|
|
analyze_type_spec(Form, Acc);
|
||
|
|
_ ->
|
||
|
|
Acc
|
||
|
|
end;
|
||
|
|
_ ->
|
||
|
|
Acc
|
||
|
|
end
|
||
|
|
end, Acc0, Tree);
|
||
|
|
_Err ->
|
||
|
|
Res
|
||
|
|
end
|
||
|
|
end, #state{}),
|
||
|
|
report_orphaned_funs(State),
|
||
|
|
RunDeps = build_deps(State#state.run_hooks, State#state.hooked_funs),
|
||
|
|
RunFoldDeps = build_deps(State#state.run_fold_hooks, State#state.hooked_funs),
|
||
|
|
emit_module(RunDeps, RunFoldDeps, State#state.specs, Dir, hooks_type_test).
|
||
|
|
|
||
|
|
analyze_form(_Form, State) ->
|
||
|
|
%% case catch erl_syntax_lib:analyze_forms(Form) of
|
||
|
|
%% Props when is_list(Props) ->
|
||
|
|
%% M = State#state.module,
|
||
|
|
%% MFAs = lists:foldl(
|
||
|
|
%% fun({F, A}, Acc) ->
|
||
|
|
%% dict:append({M, F}, A, Acc)
|
||
|
|
%% end, State#state.mfas,
|
||
|
|
%% proplists:get_value(functions, Props, [])),
|
||
|
|
%% State#state{mfas = MFAs};
|
||
|
|
%% _ ->
|
||
|
|
%% State
|
||
|
|
%% end.
|
||
|
|
State.
|
||
|
|
|
||
|
|
analyze_run_hook(Form, State) ->
|
||
|
|
[Hook|Tail] = erl_syntax:application_arguments(Form),
|
||
|
|
case atom_value(Hook, State) of
|
||
|
|
undefined ->
|
||
|
|
State;
|
||
|
|
HookName ->
|
||
|
|
Args = case Tail of
|
||
|
|
[_Host, Args0] -> Args0;
|
||
|
|
[Args0] ->
|
||
|
|
Args0
|
||
|
|
end,
|
||
|
|
Arity = erl_syntax:list_length(Args),
|
||
|
|
Hooks = dict:store({HookName, Arity},
|
||
|
|
{State#state.file, erl_syntax:get_pos(Hook)},
|
||
|
|
State#state.run_hooks),
|
||
|
|
State#state{run_hooks = Hooks}
|
||
|
|
end.
|
||
|
|
|
||
|
|
analyze_run_fold_hook(Form, State) ->
|
||
|
|
[Hook|Tail] = erl_syntax:application_arguments(Form),
|
||
|
|
case atom_value(Hook, State) of
|
||
|
|
undefined ->
|
||
|
|
State;
|
||
|
|
HookName ->
|
||
|
|
Args = case Tail of
|
||
|
|
[_Host, _Val, Args0] -> Args0;
|
||
|
|
[_Val, Args0] -> Args0
|
||
|
|
end,
|
||
|
|
Arity = erl_syntax:list_length(Args) + 1,
|
||
|
|
Hooks = dict:store({HookName, Arity},
|
||
|
|
{State#state.file, erl_syntax:get_pos(Form)},
|
||
|
|
State#state.run_fold_hooks),
|
||
|
|
State#state{run_fold_hooks = Hooks}
|
||
|
|
end.
|
||
|
|
|
||
|
|
analyze_run_fun(Form, State) ->
|
||
|
|
[Hook|Tail] = erl_syntax:application_arguments(Form),
|
||
|
|
case atom_value(Hook, State) of
|
||
|
|
undefined ->
|
||
|
|
State;
|
||
|
|
HookName ->
|
||
|
|
{Module, Fun, Seq} = case Tail of
|
||
|
|
[_Host, M, F, S] ->
|
||
|
|
{M, F, S};
|
||
|
|
[M, F, S] ->
|
||
|
|
{M, F, S}
|
||
|
|
end,
|
||
|
|
ModName = module_name(Module, State),
|
||
|
|
FunName = atom_value(Fun, State),
|
||
|
|
if ModName /= undefined, FunName /= undefined ->
|
||
|
|
Funs = dict:append(
|
||
|
|
HookName,
|
||
|
|
{ModName, FunName, integer_value(Seq, State),
|
||
|
|
{State#state.file, erl_syntax:get_pos(Form)}},
|
||
|
|
State#state.hooked_funs),
|
||
|
|
State#state{hooked_funs = Funs};
|
||
|
|
true ->
|
||
|
|
State
|
||
|
|
end
|
||
|
|
end.
|
||
|
|
|
||
|
|
analyze_iq_handler(Form, State) ->
|
||
|
|
[_Component, _Host, _NS, Module, Function, _IQDisc] =
|
||
|
|
erl_syntax:application_arguments(Form),
|
||
|
|
Mod = module_name(Module, State),
|
||
|
|
Fun = atom_value(Function, State),
|
||
|
|
if Mod /= undefined, Fun /= undefined ->
|
||
|
|
code:ensure_loaded(Mod),
|
||
|
|
case erlang:function_exported(Mod, Fun, 1) of
|
||
|
|
false ->
|
||
|
|
log("~s:~p: Error: function ~s:~s/1 is registered "
|
||
|
|
"as iq handler, but is not exported~n",
|
||
|
|
[State#state.file, erl_syntax:get_pos(Form),
|
||
|
|
Mod, Fun]);
|
||
|
|
true ->
|
||
|
|
ok
|
||
|
|
end;
|
||
|
|
true ->
|
||
|
|
ok
|
||
|
|
end,
|
||
|
|
State.
|
||
|
|
|
||
|
|
analyze_type_spec(Form, State) ->
|
||
|
|
case catch erl_syntax:revert(Form) of
|
||
|
|
{attribute, _, spec, {{F, A}, _}} ->
|
||
|
|
Specs = dict:store({State#state.module, F, A},
|
||
|
|
{Form, State#state.file},
|
||
|
|
State#state.specs),
|
||
|
|
State#state{specs = Specs};
|
||
|
|
_ ->
|
||
|
|
State
|
||
|
|
end.
|
||
|
|
|
||
|
|
build_deps(Hooks, Hooked) ->
|
||
|
|
dict:fold(
|
||
|
|
fun({Hook, Arity}, {_File, _LineNo} = Meta, Deps) ->
|
||
|
|
case dict:find(Hook, Hooked) of
|
||
|
|
{ok, Funs} ->
|
||
|
|
ExportedFuns =
|
||
|
|
lists:flatmap(
|
||
|
|
fun({M, F, Seq, {FunFile, FunLineNo} = FunMeta}) ->
|
||
|
|
code:ensure_loaded(M),
|
||
|
|
case erlang:function_exported(M, F, Arity) of
|
||
|
|
false ->
|
||
|
|
log("~s:~p: Error: function ~s:~s/~p "
|
||
|
|
"is hooked on ~s/~p, but is not "
|
||
|
|
"exported~n",
|
||
|
|
[FunFile, FunLineNo, M, F,
|
||
|
|
Arity, Hook, Arity]),
|
||
|
|
[];
|
||
|
|
true ->
|
||
|
|
[{{M, F, Arity}, Seq, FunMeta}]
|
||
|
|
end
|
||
|
|
end, Funs),
|
||
|
|
dict:append_list({Hook, Arity, Meta}, ExportedFuns, Deps);
|
||
|
|
error ->
|
||
|
|
%% log("~s:~p: Warning: hook ~p/~p is unused~n",
|
||
|
|
%% [_File, _LineNo, Hook, Arity]),
|
||
|
|
dict:append_list({Hook, Arity, Meta}, [], Deps)
|
||
|
|
end
|
||
|
|
end, dict:new(), Hooks).
|
||
|
|
|
||
|
|
report_orphaned_funs(State) ->
|
||
|
|
dict:map(
|
||
|
|
fun(Hook, Funs) ->
|
||
|
|
lists:foreach(
|
||
|
|
fun({M, F, _, {File, Line}}) ->
|
||
|
|
case get_fun_arities(M, F, State) of
|
||
|
|
[] ->
|
||
|
|
log("~s:~p: Error: function ~s:~s is "
|
||
|
|
"hooked on hook ~s, but is not exported~n",
|
||
|
|
[File, Line, M, F, Hook]);
|
||
|
|
Arities ->
|
||
|
|
case lists:any(
|
||
|
|
fun(Arity) ->
|
||
|
|
dict:is_key({Hook, Arity},
|
||
|
|
State#state.run_hooks) orelse
|
||
|
|
dict:is_key({Hook, Arity},
|
||
|
|
State#state.run_fold_hooks);
|
||
|
|
(_) ->
|
||
|
|
false
|
||
|
|
end, Arities) of
|
||
|
|
false ->
|
||
|
|
Arity = hd(Arities),
|
||
|
|
log("~s:~p: Error: function ~s:~s/~p is hooked"
|
||
|
|
" on non-existent hook ~s/~p~n",
|
||
|
|
[File, Line, M, F, Arity, Hook, Arity]);
|
||
|
|
true ->
|
||
|
|
ok
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end, Funs)
|
||
|
|
end, State#state.hooked_funs).
|
||
|
|
|
||
|
|
get_fun_arities(Mod, Fun, _State) ->
|
||
|
|
proplists:get_all_values(Fun, Mod:module_info(exports)).
|
||
|
|
|
||
|
|
module_name(Form, State) ->
|
||
|
|
try
|
||
|
|
Name = erl_syntax:macro_name(Form),
|
||
|
|
'MODULE' = erl_syntax:variable_name(Name),
|
||
|
|
State#state.module
|
||
|
|
catch _:_ ->
|
||
|
|
atom_value(Form, State)
|
||
|
|
end.
|
||
|
|
|
||
|
|
atom_value(Form, State) ->
|
||
|
|
case erl_syntax:type(Form) of
|
||
|
|
atom ->
|
||
|
|
erl_syntax:atom_value(Form);
|
||
|
|
_ ->
|
||
|
|
log("~s:~p: Warning: not an atom: ~s~n",
|
||
|
|
[State#state.file,
|
||
|
|
erl_syntax:get_pos(Form),
|
||
|
|
erl_prettypr:format(Form)]),
|
||
|
|
undefined
|
||
|
|
end.
|
||
|
|
|
||
|
|
integer_value(Form, State) ->
|
||
|
|
case erl_syntax:type(Form) of
|
||
|
|
integer ->
|
||
|
|
erl_syntax:integer_value(Form);
|
||
|
|
_ ->
|
||
|
|
log("~s:~p: Warning: not an integer: ~s~n",
|
||
|
|
[State#state.file,
|
||
|
|
erl_syntax:get_pos(Form),
|
||
|
|
erl_prettypr:format(Form)]),
|
||
|
|
0
|
||
|
|
end.
|
||
|
|
|
||
|
|
emit_module(RunDeps, RunFoldDeps, Specs, Dir, Module) ->
|
||
|
|
File = filename:join([Dir, Module]) ++ ".erl",
|
||
|
|
try
|
||
|
|
{ok, Fd} = file:open(File, [write]),
|
||
|
|
write(Fd, "-module(~s).~n~n", [Module]),
|
||
|
|
emit_export(Fd, RunDeps, "run hooks"),
|
||
|
|
emit_export(Fd, RunFoldDeps, "run_fold hooks"),
|
||
|
|
emit_run_hooks(Fd, RunDeps, Specs),
|
||
|
|
emit_run_fold_hooks(Fd, RunFoldDeps, Specs),
|
||
|
|
write(Fd, "bypass_stop({stop, Acc}) -> Acc;~n"
|
||
|
|
"bypass_stop(Acc) -> Acc.~n", []),
|
||
|
|
file:close(Fd),
|
||
|
|
log("Module written to file ~s~n", [File])
|
||
|
|
catch _:{badmatch, {error, Reason}} ->
|
||
|
|
log("writing to ~s failed: ~s", [File, file:format_error(Reason)])
|
||
|
|
end.
|
||
|
|
|
||
|
|
emit_run_hooks(Fd, Deps, Specs) ->
|
||
|
|
DepsList = lists:sort(dict:to_list(Deps)),
|
||
|
|
lists:foreach(
|
||
|
|
fun({{Hook, Arity, {File, LineNo}}, []}) ->
|
||
|
|
Args = lists:duplicate(Arity, "_"),
|
||
|
|
write(Fd, "%% called at ~s:~p~n", [File, LineNo]),
|
||
|
|
write(Fd, "~s(~s) -> ok.~n~n", [Hook, string:join(Args, ", ")]);
|
||
|
|
({{Hook, Arity, {File, LineNo}}, Funs}) ->
|
||
|
|
emit_specs(Fd, Funs, Specs),
|
||
|
|
write(Fd, "%% called at ~s:~p~n", [File, LineNo]),
|
||
|
|
Args = string:join(
|
||
|
|
[[N] || N <- lists:sublist(lists:seq($A, $Z), Arity)],
|
||
|
|
", "),
|
||
|
|
write(Fd, "~s(~s) ->~n ", [Hook, Args]),
|
||
|
|
Calls = [io_lib:format("~s:~s(~s)", [Mod, Fun, Args])
|
||
|
|
|| {{Mod, Fun, _}, _Seq, _} <- lists:keysort(2, Funs)],
|
||
|
|
write(Fd, "~s.~n~n", [string:join(Calls, ",\n ")])
|
||
|
|
end, DepsList).
|
||
|
|
|
||
|
|
emit_run_fold_hooks(Fd, Deps, Specs) ->
|
||
|
|
DepsList = lists:sort(dict:to_list(Deps)),
|
||
|
|
lists:foreach(
|
||
|
|
fun({{Hook, Arity, {File, LineNo}}, []}) ->
|
||
|
|
write(Fd, "%% called at ~s:~p~n", [File, LineNo]),
|
||
|
|
Args = ["Acc"|lists:duplicate(Arity - 1, "_")],
|
||
|
|
write(Fd, "~s(~s) -> Acc.~n~n", [Hook, string:join(Args, ", ")]);
|
||
|
|
({{Hook, Arity, {File, LineNo}}, Funs}) ->
|
||
|
|
emit_specs(Fd, Funs, Specs),
|
||
|
|
write(Fd, "%% called at ~s:~p~n", [File, LineNo]),
|
||
|
|
Args = [[N] || N <- lists:sublist(lists:seq($A, $Z), Arity - 1)],
|
||
|
|
write(Fd, "~s(~s) ->", [Hook, string:join(["Acc"|Args], ", ")]),
|
||
|
|
FunsCascade = make_funs_cascade(
|
||
|
|
lists:reverse(lists:keysort(2, Funs)),
|
||
|
|
1, Args),
|
||
|
|
write(Fd, "~s.~n~n", [FunsCascade])
|
||
|
|
end, DepsList).
|
||
|
|
|
||
|
|
make_funs_cascade([{{Mod, Fun, _}, _Seq, _}|Funs], N, Args) ->
|
||
|
|
io_lib:format("~n~sbypass_stop(~s:~s(~s))",
|
||
|
|
[lists:duplicate(N, " "),
|
||
|
|
Mod, Fun, string:join([make_funs_cascade(Funs, N+1, Args)|Args], ", ")]);
|
||
|
|
make_funs_cascade([], _N, _Args) ->
|
||
|
|
"Acc".
|
||
|
|
|
||
|
|
emit_export(Fd, Deps, Comment) ->
|
||
|
|
DepsList = lists:sort(dict:to_list(Deps)),
|
||
|
|
Exports = lists:map(
|
||
|
|
fun({{Hook, Arity, _}, _}) ->
|
||
|
|
io_lib:format("~s/~p", [Hook, Arity])
|
||
|
|
end, DepsList),
|
||
|
|
write(Fd, "%% ~s~n-export([~s]).~n~n",
|
||
|
|
[Comment, string:join(Exports, ",\n ")]).
|
||
|
|
|
||
|
|
emit_specs(Fd, Funs, Specs) ->
|
||
|
|
lists:foreach(
|
||
|
|
fun({{M, _, _} = MFA, _, _}) ->
|
||
|
|
case dict:find(MFA, Specs) of
|
||
|
|
{ok, {Form, _File}} ->
|
||
|
|
Lines = string:tokens(erl_syntax:get_ann(Form), "\n"),
|
||
|
|
lists:foreach(
|
||
|
|
fun("%" ++ _) ->
|
||
|
|
ok;
|
||
|
|
("-spec" ++ Spec) ->
|
||
|
|
write(Fd, "%% -spec ~p:~s~n",
|
||
|
|
[M, string:strip(Spec, left)]);
|
||
|
|
(Line) ->
|
||
|
|
write(Fd, "%% ~s~n", [Line])
|
||
|
|
end, Lines);
|
||
|
|
error ->
|
||
|
|
ok
|
||
|
|
end
|
||
|
|
end, lists:keysort(2, Funs)).
|
||
|
|
|
||
|
|
get_forms(Path) ->
|
||
|
|
case file:open(Path, [read]) of
|
||
|
|
{ok, Fd} ->
|
||
|
|
parse(Path, Fd, 1, []);
|
||
|
|
Err ->
|
||
|
|
Err
|
||
|
|
end.
|
||
|
|
|
||
|
|
parse(Path, Fd, Line, Acc) ->
|
||
|
|
{ok, Pos} = file:position(Fd, cur),
|
||
|
|
case epp_dodger:parse_form(Fd, Line) of
|
||
|
|
{ok, Form, NewLine} ->
|
||
|
|
{ok, NewPos} = file:position(Fd, cur),
|
||
|
|
{ok, RawForm} = file:pread(Fd, Pos, NewPos - Pos),
|
||
|
|
file:position(Fd, {bof, NewPos}),
|
||
|
|
AnnForm = erl_syntax:set_ann(Form, RawForm),
|
||
|
|
parse(Path, Fd, NewLine, [AnnForm|Acc]);
|
||
|
|
{eof, _} ->
|
||
|
|
{ok, NewPos} = file:position(Fd, cur),
|
||
|
|
if NewPos > Pos ->
|
||
|
|
{ok, RawForm} = file:pread(Fd, Pos, NewPos - Pos),
|
||
|
|
Form = erl_syntax:text(""),
|
||
|
|
AnnForm = erl_syntax:set_ann(Form, RawForm),
|
||
|
|
{ok, lists:reverse([AnnForm|Acc])};
|
||
|
|
true ->
|
||
|
|
{ok, lists:reverse(Acc)}
|
||
|
|
end;
|
||
|
|
{error, {_, _, ErrDesc}, LineNo} = Err ->
|
||
|
|
log("~s:~p: Error: ~s~n",
|
||
|
|
[Path, LineNo, erl_parse:format_error(ErrDesc)]),
|
||
|
|
Err
|
||
|
|
end.
|
||
|
|
|
||
|
|
log(Format, Args) ->
|
||
|
|
io:format(standard_io, Format, Args).
|
||
|
|
|
||
|
|
write(Fd, Format, Args) ->
|
||
|
|
file:write(Fd, io_lib:format(Format, Args)).
|