xmpp.chapril.org-ejabberd/rebar.config.script

387 lines
11 KiB
Plaintext
Raw Normal View History

2016-12-27 10:44:07 +01:00
%%%----------------------------------------------------------------------
%%%
2020-01-28 13:34:02 +01:00
%%% ejabberd, Copyright (C) 2002-2020 ProcessOne
2016-12-27 10:44:07 +01:00
%%%
%%% This program is free software; you can redistribute it and/or
%%% modify it under the terms of the GNU General Public License as
%%% published by the Free Software Foundation; either version 2 of the
%%% License, or (at your option) any later version.
%%%
%%% This program is distributed in the hope that it will be useful,
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
%%% General Public License for more details.
%%%
%%% You should have received a copy of the GNU General Public License along
%%% with this program; if not, write to the Free Software Foundation, Inc.,
%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
%%%
%%%----------------------------------------------------------------------
Vars = case file:consult(filename:join([filename:dirname(SCRIPT),"vars.config"])) of
2017-01-26 16:43:47 +01:00
{ok, Terms} ->
Terms;
_Err ->
[]
end ++ [{cflags, "-g -O2 -Wall"}, {cppflags, "-g -O2 -Wall"},
{ldflags, ""}, {system_deps, false}],
2017-01-26 16:43:47 +01:00
{cflags, CFlags} = lists:keyfind(cflags, 1, Vars),
{cppflags, CPPFlags} = lists:keyfind(cppflags, 1, Vars),
{ldflags, LDFlags} = lists:keyfind(ldflags, 1, Vars),
{system_deps, SystemDeps} = lists:keyfind(system_deps, 1, Vars),
2017-01-26 16:43:47 +01:00
GetCfg = fun GetCfg(Cfg, [Key | Tail], Default) ->
2017-01-26 16:43:47 +01:00
Val = case lists:keyfind(Key, 1, Cfg) of
{Key, V1} -> V1;
false -> Default
end,
case Tail of
[] ->
Val;
_ ->
GetCfg(Val, Tail, Default)
2017-01-26 16:43:47 +01:00
end
end,
ModCfg = fun ModCfg(Cfg, [Key | Tail], Op, Default) ->
2017-01-26 16:43:47 +01:00
{OldVal, PartCfg} = case lists:keytake(Key, 1, Cfg) of
{value, {_, V1}, V2} -> {V1, V2};
false -> {if Tail == [] -> Default; true -> [] end, Cfg}
end,
case Tail of
[] ->
[{Key, Op(OldVal)} | PartCfg];
_ ->
[{Key, ModCfg(OldVal, Tail, Op, Default)} | PartCfg]
2017-01-26 16:43:47 +01:00
end
end,
FilterConfig = fun FilterConfig(Cfg, [{Path, true, ModFun, Default} | Tail]) ->
FilterConfig(ModCfg(Cfg, Path, ModFun, Default), Tail);
FilterConfig(Cfg, [{Path, SourcePath, true, ModFun, Default, SourceDefault} | Tail]) ->
SourceVal = GetCfg(Cfg, SourcePath, SourceDefault),
2017-01-26 16:43:47 +01:00
ModFun2 = fun(V) -> ModFun(V, SourceVal) end,
FilterConfig(ModCfg(Cfg, Path, ModFun2, Default), Tail);
FilterConfig(Cfg, [_ | Tail]) ->
FilterConfig(Cfg, Tail);
FilterConfig(Cfg, []) ->
2017-01-26 16:43:47 +01:00
Cfg
end,
2016-03-21 12:01:20 +01:00
2016-11-24 14:07:08 +01:00
IsRebar3 = case application:get_key(rebar, vsn) of
{ok, VSN} ->
[VSN1 | _] = string:tokens(VSN, "-"),
[Maj|_] = string:tokens(VSN1, "."),
2016-11-24 14:07:08 +01:00
(list_to_integer(Maj) >= 3);
undefined ->
lists:keymember(mix, 1, application:loaded_applications())
end,
2017-01-26 16:43:47 +01:00
SysVer = erlang:system_info(otp_release),
ProcessSingleVar = fun(F, Var, Tail) ->
case F([Var], []) of
[] -> Tail;
[Val] -> [Val | Tail]
end
end,
ProcessVars = fun F([], Acc) ->
2017-01-26 16:43:47 +01:00
lists:reverse(Acc);
F([{Type, Ver, Value} | Tail], Acc) when
2017-01-26 16:43:47 +01:00
Type == if_version_above orelse
Type == if_version_below ->
SysVer = erlang:system_info(otp_release),
Include = if Type == if_version_above ->
SysVer > Ver;
true ->
SysVer < Ver
end,
if Include ->
F(Tail, ProcessSingleVar(F, Value, Acc));
true ->
F(Tail, Acc)
end;
F([{Type, Ver, Value, ElseValue} | Tail], Acc) when
2017-01-26 16:43:47 +01:00
Type == if_version_above orelse
Type == if_version_below ->
Include = if Type == if_version_above ->
SysVer > Ver;
true ->
SysVer < Ver
end,
if Include ->
F(Tail, ProcessSingleVar(F, Value, Acc));
true ->
F(Tail, ProcessSingleVar(F, ElseValue, Acc))
2017-01-26 16:43:47 +01:00
end;
F([{Type, Var, Value} | Tail], Acc) when
2017-01-26 16:43:47 +01:00
Type == if_var_true orelse
Type == if_var_false ->
Flag = Type == if_var_true,
case proplists:get_bool(Var, Vars) of
V when V == Flag ->
F(Tail, ProcessSingleVar(F, Value, Acc));
2017-01-26 16:43:47 +01:00
_ ->
F(Tail, Acc)
2017-01-26 16:43:47 +01:00
end;
F([{Type, Value} | Tail], Acc) when
2017-01-26 16:43:47 +01:00
Type == if_rebar3 orelse
Type == if_not_rebar3 ->
Flag = Type == if_rebar3,
case IsRebar3 == Flag of
true ->
F(Tail, ProcessSingleVar(F, Value, Acc));
2017-01-26 16:43:47 +01:00
_ ->
F(Tail, Acc)
2017-01-26 16:43:47 +01:00
end;
F([{Type, Var, Match, Value} | Tail], Acc) when
2017-01-26 16:43:47 +01:00
Type == if_var_match orelse
Type == if_var_no_match ->
case proplists:get_value(Var, Vars) of
V when V == Match ->
F(Tail, ProcessSingleVar(F, Value, Acc));
2017-01-26 16:43:47 +01:00
_ ->
F(Tail, Acc)
end;
F([{if_have_fun, MFA, Value} | Tail], Acc) ->
{Mod, Fun, Arity} = MFA,
code:ensure_loaded(Mod),
case erlang:function_exported(Mod, Fun, Arity) of
true ->
F(Tail, ProcessSingleVar(F, Value, Acc));
false ->
F(Tail, Acc)
end;
F([Other1 | Tail1], Acc) ->
F(Tail1, [F(Other1, []) | Acc]);
F(Val, Acc) when is_tuple(Val) ->
list_to_tuple(F(tuple_to_list(Val), Acc));
F(Other2, _Acc) ->
2017-01-26 16:43:47 +01:00
Other2
end,
MaybeApply = fun(Val) when is_function(Val) ->
Val();
(Val) ->
Val
end,
MaybeApply2 = fun(Val, Arg) when is_function(Val) ->
Val(Arg);
(Val, _) ->
Val
end,
AppendStr = fun(Append) ->
fun("") ->
lists:flatten(MaybeApply(Append));
(Val) ->
lists:flatten([Val, " ", MaybeApply(Append)])
end
end,
AppendList = fun(Append) ->
fun(Val) ->
Val ++ MaybeApply(Append)
end
end,
AppendStr2 = fun(Append) ->
fun("", Arg) ->
lists:flatten(MaybeApply2(Append, Arg));
(Val, Arg) ->
lists:flatten([Val, " ", MaybeApply2(Append, Arg)])
end
end,
AppendList2 = fun(Append) ->
fun(Val, Arg) ->
Val ++ MaybeApply2(Append, Arg)
end
end,
Rebar3DepsFilter =
fun(DepsList) ->
lists:map(fun({DepName, _, {git, _, {tag, Version}}}) ->
{DepName, Version};
(Dep) ->
Dep
end, DepsList)
end,
DepAlts = fun("esip") -> ["esip", "p1_sip"];
("xmpp") -> ["xmpp", "p1_xmpp"];
("fast_xml") -> ["fast_xml", "p1_xml"];
(Val) -> [Val]
end,
LibDirInt = fun F([Dep|Rest], Suffix) ->
case code:lib_dir(Dep) of
{error, _} ->
F(Rest, Suffix);
V -> V ++ Suffix
end;
F([], _) ->
error
end,
LibDir = fun(Name, Suffix) ->
LibDirInt(DepAlts(Name), Suffix)
end,
2017-01-26 16:43:47 +01:00
GlobalDepsFilter =
fun(Deps) ->
DepNames = lists:map(fun({DepName, _, _}) -> DepName;
({DepName, _}) -> DepName
end, Deps),
lists:filtermap(fun(Dep) ->
case LibDir(atom_to_list(Dep), "") of
error ->
exit("Unable to locate dep '" ++ atom_to_list(Dep) ++ "' in system deps.");
2017-01-26 16:43:47 +01:00
_ ->
false
end
end, DepNames)
end,
{ok, Cwd} = file:get_cwd(),
TestConfigFile = filename:join([Cwd, "test", "config.ctc"]),
TestConfig = case file:read_file_info(TestConfigFile) of
2017-01-26 16:43:47 +01:00
{ok, _} ->
2017-02-14 14:34:02 +01:00
[" -userconfig ct_config_plain ", TestConfigFile, " "];
2017-01-26 16:43:47 +01:00
_ ->
""
end,
2017-10-30 13:55:10 +01:00
ResolveDepPath = case {SystemDeps, IsRebar3} of
{true, _} ->
2016-11-24 14:07:08 +01:00
fun("deps/" ++ Rest) ->
Slash = string:str(Rest, "/"),
case LibDir(string:sub_string(Rest, 1, Slash -1), string:sub_string(Rest, Slash)) of
error -> Rest;
V -> V
end;
2017-10-30 13:55:10 +01:00
(Path) ->
Path
end;
{_, true} ->
fun("deps/" ++ Rest) ->
Slash = string:str(Rest, "/"),
"_build/default/lib/" ++
string:sub_string(Rest, 1, Slash - 1) ++
string:sub_string(Rest, Slash);
2016-11-24 14:07:08 +01:00
(Path) ->
Path
end;
_ ->
fun(P) ->
2017-01-26 16:43:47 +01:00
P
2016-11-24 14:07:08 +01:00
end
end,
2017-01-26 16:43:47 +01:00
CtParams = fun(CompileOpts) ->
["-ct_hooks cth_surefire ",
lists:map(fun({i, IncPath}) ->
[" -include ", filename:absname(ResolveDepPath(IncPath), Cwd)]
2017-01-26 16:43:47 +01:00
end, CompileOpts),
TestConfig]
end,
2017-01-26 16:43:47 +01:00
GenDepConfigureLine =
fun(DepPath, Flags) ->
["sh -c 'if test ! -f config.status -o ",
"../../config.status -nt config.status; ",
"then (",
2017-01-26 16:43:47 +01:00
"CFLAGS=\"", CFlags,"\" ",
"CPPFLAGS=\"", CPPFlags, "\" "
"LDFLAGS=\"", LDFlags, "\"",
" ./configure ", string:join(Flags, " "),
"); fi'"]
end,
GenDepsConfigure =
fun(Hooks) ->
lists:map(fun({Pkg, Flags}) ->
DepPath = ResolveDepPath("deps/" ++ Pkg ++ "/"),
Line = lists:flatten(GenDepConfigureLine(DepPath, Flags)),
{add, list_to_atom(Pkg), [{pre_hooks, [{{pc, compile}, Line}, {'compile', Line}, {'configure-deps', Line}]}]}
2017-01-26 16:43:47 +01:00
end, Hooks)
end,
ProcessErlOpt = fun(Vals) ->
R = lists:map(
2017-01-26 16:43:47 +01:00
fun({i, Path}) ->
{i, ResolveDepPath(Path)};
(ErlOpt) ->
ErlOpt
end, Vals),
M = lists:filter(fun({d, M}) -> true; (_) -> false end, R),
[{d, 'ALL_DEFS', M} | R]
2017-01-26 16:43:47 +01:00
end,
ProcssXrefExclusions = fun(Items) ->
[{lists:flatten(["(XC - UC) || (XU - X - B ",
[[" - ", V] || V <- Items], ")"]),
[]}]
end,
ProcessFloatingDeps =
fun(Deps, FDeps) ->
lists:map(fun({DepName, _Ver, {git, Repo, _Commit}} = Dep) ->
case lists:member(DepName, FDeps) of
true ->
{DepName, ".*", {git, Repo}};
_ ->
Dep
end;
(Dep2) ->
Dep2
end, Deps)
end,
TravisPostHooks =
fun(true) ->
[{eunit, "echo '\n%%! -pa .eunit/ deps/coveralls/ebin\n" ++
"main(_)->{ok,F}=file:open(\"erlang.json\",[write])," ++
"io:fwrite(F,\"~s\",[coveralls:convert_file(" ++
"\".eunit/cover.coverdata\", \"" ++
os:getenv("TRAVIS_JOB_ID") ++
"\", \"travis-ci\",\"\")]).' > getcover.erl"},
{eunit, "escript ./getcover.erl"}];
(_) ->
[]
end,
Rules = [
{[provider_hooks], IsRebar3,
AppendList([{pre, [
{compile, {asn, compile}},
{clean, {asn, clean}}
]}]), []},
{[deps], os:getenv("TRAVIS") == "true",
2020-01-17 08:59:10 +01:00
AppendList([{coveralls, ".*", {git, "https://github.com/markusn/coveralls-erl.git", {tag, "v2.0.1"}}}]), []},
2017-01-26 16:43:47 +01:00
{[post_hooks], [cover_enabled], os:getenv("TRAVIS") == "true",
AppendList2(TravisPostHooks), [], false},
2017-10-30 13:55:10 +01:00
{[overrides], [post_hook_configure], SystemDeps == false,
2017-01-26 16:43:47 +01:00
AppendList2(GenDepsConfigure), [], []},
{[ct_extra_params], [eunit_compile_opts], true,
AppendStr2(CtParams), "", []},
{[erl_opts], true,
ProcessErlOpt, []},
{[xref_queries], [xref_exclusions], true,
AppendList2(ProcssXrefExclusions), [], []},
{[deps], [floating_deps], true,
2017-01-26 16:43:47 +01:00
ProcessFloatingDeps, [], []},
{[deps], IsRebar3,
Rebar3DepsFilter, []},
{[deps], SystemDeps /= false,
2017-01-26 16:43:47 +01:00
GlobalDepsFilter, []}
],
Config = [{plugin_dir, filename:join([filename:dirname(SCRIPT),"plugins"])}]++
FilterConfig(ProcessVars(CONFIG, []), Rules),
2017-01-26 16:43:47 +01:00
%io:format("ejabberd configuration:~n ~p~n", [Config]),
2016-11-24 14:07:08 +01:00
2017-01-26 16:43:47 +01:00
Config.
%% Local Variables:
%% mode: erlang
%% End:
%% vim: set filetype=erlang tabstop=8: