rebar.config.script

%% Strip any combination of newline and whitespace off both ends of S
StrStrip = fun(S, F, S) ->
                   S;
              (S, F, _) ->
                   F(string:strip(string:strip(S, both, $\n), both), F, S)
           end.

StrClean = fun(S) ->
                   StrStrip(S, StrStrip, "")
           end.


IsFalsy = fun(false) -> true;
             (S) when is_list(S) -> StrClean(S) =:= [];
             (_) -> false
          end.

IsTruthy = fun(true) -> true;
              (S) when is_list(S) -> StrClean(S) =/= [];
              (_) -> false
           end.

GetEnv =
    fun F(EnvVar, {IfFalsyFun, IfTruthyFun}) when is_function(IfFalsyFun, 1) andalso
                                                  is_function(IfTruthyFun, 1) ->
           case IsTruthy(Val = os:getenv(EnvVar)) of
               true  -> IfTruthyFun(Val);
               false -> IfFalsyFun(Val)
           end;
       F(EnvVar, {IfFalsyFun}) ->
           F(EnvVar, IfFalsyFun);
       F(EnvVar, bool) ->
           F(EnvVar, {fun(_) -> false end, fun(_) -> true end});
       F(EnvVar, IfFalsyFun) when is_function(IfFalsyFun, 1) ->
           F(EnvVar, {IfFalsyFun, StrClean})
    end.




%% If EnvVar exists and has some content, call UserFun(Content, UserArg)
%% and return its result.
%% Otherwise return UserArg unchanged.
RunIfEnvVar =
    fun(EnvVar, UserFun, UserArg) ->
        IfFalsyFun = fun(_) -> UserArg end,
        IfTruthyFun = fun(Val) -> UserFun(Val, UserArg) end,
        GetEnv(EnvVar, {IfFalsyFun, IfTruthyFun})
    end.

IsDbg = GetEnv("REBAR_EXTRA_DBG", bool).

DbgDo = fun(F) when is_function(F, 0) -> IsDbg andalso F() end.
DbgMsg = fun(Fmt, Args) -> DbgDo(fun() -> io:format(Fmt, Args) end) end.
Msg = fun(Fmt, Args) ->
              io:format(standard_error, Fmt, Args),
              true
      end.


DbgMsg("CONFIG: ~p~n", [CONFIG]).

GetFileAppVersion = fun() ->
                            case file:read_file("APP_VERSION") of
                                {ok, BVsn} ->
                                    DbgMsg("File vsn: ~p~n", [BVsn]),
                                    S = StrClean(binary_to_list(BVsn)),
                                    DbgMsg("Cleaned vsn: ~p~n", [S]),
                                    S;
                                _ ->
                                    undefined
                            end
                    end.

GetAppVersion =
    fun() -> GetEnv("APP_VERSION", fun(_) -> GetFileAppVersion() end) end.

%% Ensure edown target is valid
ValTarget = fun(Target) ->
                    ATarget = list_to_atom(Target),
                    lists:member(ATarget, ['github', 'gitlab', 'stash'])
                        orelse throw({bad_edown_target, Target}),
                    ATarget
            end.

GetCfg = fun(Key, Config, Default) ->
                      case lists:keyfind(Key, 1, Config) of
                          false ->
                              Default;
                          {Key, PL} ->
                              PL
                      end
              end.

KeyStore = fun(Key, Config, NewVal) ->
               lists:keystore(Key, 1, Config, {Key, NewVal})
          end.

GetEDocOpts = fun(Config) -> GetCfg(edoc_opts, Config, []) end.
GetPreHooks = fun(Config) -> GetCfg(pre_hooks, Config, []) end.
SetPreHooks = fun(PreHooks, Config) ->
                      KeyStore(pre_hooks, Config, PreHooks)
              end.
GetCTHook = fun(PreHooks) -> GetCfg(ct, PreHooks, undefined) end.
SetCTHook = fun(CTHook, PreHooks) ->
                    KeyStore(ct, PreHooks, CTHook)
            end.
GetCTOpts = fun(Config) -> GetCfg(ct_opts, Config, []) end.
SetCTOpts = fun(NewVal, Config) -> KeyStore(ct_opts, Config, NewVal) end.
GetCTSpec = fun(CTOpts) -> GetCfg(spec, CTOpts, undefined) end.
SetCTSpec = fun(NewVal, CTOpts) -> KeyStore(spec, CTOpts, NewVal) end.

GetFullHostname = fun() -> net_adm:localhost() end.

MakeLongNodeB = fun(NodeName, HostName) ->
                        list_to_binary([NodeName, $@, HostName])
                end.

MakeLongNodeS = fun(NodeName, HostName) ->
                        NodeName ++ "@" ++ HostName
                end.

LONG_NODE_NAME_BIN = fun() ->
                             HostN = GetFullHostname(),
                             MakeLongNodeB("ct1_apns_erlv3", HostN)
                     end.

LONG_NODE_NAME_ATOM =
    fun() ->
            list_to_atom(binary_to_list(LONG_NODE_NAME_BIN()))
    end.

ConfigureCTOpts =
     fun(Config) ->
             DbgMsg("In ConfigureCTOpts~n", []),
             DbgMsg("Config IN: ~p~n", [Config]),
             CTOpts0 = GetCTOpts(Config),
             CTSpec0 = case GetCTSpec(CTOpts0) of
                           undefined ->
                               % This MUST be a list of specs!
                               ["apns_erlv3.test.spec"];
                           S -> S
                       end,
             CTOpts = SetCTSpec(CTSpec0, CTOpts0),
             ConfigOut = SetCTOpts(CTOpts, Config),
             DbgMsg("Config OUT: ~p~n", [ConfigOut]),
             ConfigOut
        end.

%% This function generates the test spec file needed by common test.
%% It expects a file to exist, $SPEC_NAME.src, where $SPEC_NAME
%% is defined as returned by ConfigureCTOpts.
%%
%% $SPEC_NAME.src must contain a stanza as follows:
%%
%% {node, ct1, '{{NEEDFULLNODENAME}}'}.
%%
%% This function replaces {{NEEDFULLNODENAME}} with the long node
%% name of the node running rebar3 and saves the file as $SPECNAME.
%%
GenerateTestSpec =
    fun(Config0) ->
            Template = <<"{{NEEDFULLNODENAME}}">>,
            Config = ConfigureCTOpts(Config0),
            CTSpec = GetCTSpec(GetCTOpts(Config)),
            true = (CTSpec /= undefined),
            CTSpecSrc = CTSpec ++ ".src",
            Res = case file:read_file(CTSpecSrc) of
                      {ok, Spec0} ->
                          true = (binary:match(Spec0, Template) /= nomatch),
                          Spec = binary:replace(Spec0, Template, LONG_NODE_NAME_BIN()),
                          ok = file:write_file(CTSpec, Spec),
                          Config;
                      Error ->
                          Msg("Error opening ~s: ~p\n", [CTSpecSrc, Error]),
                          undefined
                  end,
            DbgMsg("GenerateTestSpec returned ~p\n", [Res]),
            Res
    end.

UpsertDistNode =
    fun(Config, LongNodeName, Cookie) when is_atom(LongNodeName),
                                           is_atom(Cookie) ->
            DistNode = {dist_node, [{name, LongNodeName}, {setcookie, Cookie}]},
            lists:keystore(dist_node, 1, Config, DistNode)
    end.

ConfigurePreHooks = fun(Config0) ->
                            Config = ConfigureCTOpts(Config0),
                            CTSpec = GetCTSpec(GetCTOpts(Config)),
                            true = (CTSpec /= undefined),
                            Script = "./pre_common_test_hook.sh",
                            PreHooks = GetPreHooks(Config),
                            HostN = GetFullHostname(),
                            NodeName = MakeLongNodeS("ct1_apns_erlv3", HostN),
                            CTHook = case GetCTHook(PreHooks) of
                                         S when S == undefined orelse
                                                S == Script ->
                                             lists:flatten(
                                                 string:join([Script,
                                                              NodeName,
                                                              CTSpec], " ")
                                             );
                                         S ->
                                             S
                                     end,
                            PreHooks1 = SetCTHook(CTHook, PreHooks),
                            SetPreHooks(PreHooks1, Config)
                    end.

ChangeEdownUrl = fun(Url, Cfg) ->
                         EDocOpts = KeyStore(top_level_readme,
                                             GetEDocOpts(Cfg),
                                             {"./README.md", Url}),
                         KeyStore(edoc_opts, Cfg, EDocOpts)
                 end.

%% If env var is defined, replace edown_target with its contents
ChangeEdownTarget = fun(Target, Cfg) ->
                            EDocOpts = KeyStore(edown_target,
                                                GetEDocOpts(Cfg),
                                                ValTarget(Target)),
                            KeyStore(edoc_opts, Cfg, EDocOpts)
                    end.

%%
%% Funs that run the change function if the environment variable is present.
%%
CfgEdownUrl = fun(Cfg) ->
                      RunIfEnvVar("EDOWN_TOP_LEVEL_README_URL",
                                  ChangeEdownUrl, Cfg)
              end.

CfgEdownTarget = fun(Cfg) ->
                         RunIfEnvVar("EDOWN_TARGET", ChangeEdownTarget, Cfg)
                 end.

%% Override edoc '@version' macro value to be current APP_VERSION.
CfgVersion = fun(Cfg) ->
                     case GetAppVersion() of
                         Vsn when is_list(Vsn) ->
                             DbgMsg("APP_VERSION: ~s~n", [Vsn]),
                             VsnDef = {version, Vsn},
                             Opts0 = proplists:get_value(edoc_opts, Cfg, []),
                             Defs = case proplists:get_value(def, Opts0, []) of
                                        Macros when is_list(Macros) ->
                                            [VsnDef | Macros -- [VsnDef]];
                                        {_Name, _Str} = Macro ->
                                            [VsnDef | [Macro] -- [VsnDef]]
                                    end,
                             Opts = lists:keystore(def, 1, Opts0, {def, Defs}),
                             lists:keystore(edoc_opts, 1, Cfg,
                                            {edoc_opts, Opts});
                         undefined ->
                             Cfg
                     end
             end.

CfgCtOverride =
    fun(Cfg) ->
            GetEnv("CT_OVERRIDE",
                   {fun(_) ->
                            DbgMsg("Configuring pre_hooks", []),
                            ConfigurePreHooks(Cfg)
                    end,
                    fun(_) ->
                            DbgMsg("CT_OVERRIDE, no ct pre_hooks", []),
                            Cfg
                    end})
    end.

%%{pre_hooks, [{ct, "./pre_common_test_hook.sh"}]}.

%% Common Test configuration: ensure that the CT long node name
%% uses the current dns host name.

%%{pre_hooks, [{ct, "./pre_common_test_hook.sh"}]}.
%%{ct_opts, [{spec, "apns_erlv3.test.spec"}]}.

CfgDistNode =
    fun(Cfg) ->
            Cookie = 'apns_erlv3',
            UpsertDistNode(Cfg, LONG_NODE_NAME_ATOM(), Cookie)
    end.

%% Chain the config change functions
RunChangeFuns =
    fun(Config) ->
            NC = lists:foldl(fun(F, Cfg) -> F(Cfg) end,
                             Config,
                             [GenerateTestSpec, CfgEdownUrl, CfgEdownTarget,
                              CfgVersion, CfgCtOverride, CfgDistNode]),
            DbgMsg("Final config:~n~p~n", [NC]),
            NC
     end.

RunChangeFuns(CONFIG).