devsetup

#!/usr/bin/env escript
%% -*- erlang -*-
%%! -pz deps/setup/ebin

-mode(compile).

main(Opts) ->
    try
        CLIOpts = opts(Opts),
        build_reltool_config(CLIOpts),
        setup_gen:run([
		       {name, "exodm"},
		       {relconf, "rel/reltool.config"},
		       {sys, "rel/sys.config"},
		       {outdir, "./devel"},
		       {install, true},
		       {verbose, true},
		       {env, [
			      {setup,
			       [
				{data_dir, "db"}
			       ]}
			     ]},
		       {pa,filename:absname("./ebin")},
		       {root, filename:absname("deps")},
		       {root, filename:absname("lib")},
		       {wild_roots, true}
		       | CLIOpts
		      ])
    catch
	error:E ->
	    io:fwrite("ERROR: ~p~n"
		      "Trace: ~p~n", [E, erlang:get_stacktrace()]),
	    timer:sleep(500),
	    halt(1)
    end.

opts(["-target","false" | Rest]) ->
    [{target, false} | opts(Rest)];
opts(["-target", T | Rest]) ->
    [{target, T}| opts(Rest)];
opts(["-vsn", V | Rest]) ->
    [{vsn, V} | opts(Rest)];
opts([Opt | Opts]) ->
    io:fwrite("WARNING: Ignoring option ~p~n", [Opt]),
    opts(Opts);
opts([]) ->
    [].

build_reltool_config(Opts) ->
    {ok, Old} = file:get_cwd(),
    file:set_cwd("rel"),
    try
        case file:consult("reltool.config.src") of
            {ok, Terms} ->
                Vars = [{"TARGET", get_target(Opts)},
                        {"VSN", get_vsn(Opts)}],
                Env = env(),
                New = lists:map(fun(T) -> expand(T, Env) end,
                                expand_env(Vars, Terms)),
                write_to_file("reltool.config", New),
                ok;
            ok ->
                ok
        end
    after
        file:set_cwd(Old)
    end.
                                     

env() ->
    Scr = "rebar.config.script",
    Cfg = "rebar.config",
    {ok, Terms} = file:consult(Cfg),
    case filelib:is_regular(Scr) of
        true ->
            {ok, Terms2} =
                file:script(Scr, [{'CONFIG', Terms},
                                  {'SCRIPT',Scr}]),
            Terms2;
        false ->
            Terms
    end.
                
expand({sys, Params}, Env) ->
    Ps1 = [P || P <- Params,
		element(1,P) =/= app
          ],
    Ps2 = replace_rels(Ps1, Env),
    AllApps = lists:usort(
                  [app_name(A) ||
	              A <- lists:concat(
                             [As || {rel,_,_,As} <- Ps2])]),
    {sys, fix_apps(fix_lib_dirs(AllApps,
                                Ps2 ++ [{app,A,[{incl_cond, include}]}
					|| A <- AllApps]))};
expand(T, _) ->
    T.

expand_env(Vs, T) when is_tuple(T) ->
    list_to_tuple([expand_env(Vs, X) || X <- tuple_to_list(T)]);
expand_env(Vs, L) when is_list(L) ->
    case is_string(L) of
        true ->
            do_expand_env(L, Vs, list);
        false ->
            [expand_env(Vs, X) || X <- L]
    end;
expand_env(Vs, B) when is_binary(B) ->
    do_expand_env(B, Vs, binary);
expand_env(_, X) ->
    X.

do_expand_env(X, Vs, Type) ->
    lists:foldl(fun({K, Val}, Xx) ->
                        re:replace(Xx, [$\\, $$ | K], Val, [{return,Type}])
                end, X, Vs).

is_string(S) ->
    lists:all(fun(C) when 0 < C, C =< 255 -> true;
                 (_) -> false
              end, S).


get_target(Env) ->
    case lists:keyfind(target, 1, Env) of
        {_, false} -> "exodm";
	{_, T} ->
            lists:last(filename:split(T));
        false ->
            io:fwrite("No target specified~n"
                      "Rebar globals = ~p~n",
                      [application:get_all_env(rebar)]),
            "exodm"
    end.

get_vsn(Env) ->
    case lists:keyfind(vsn, 1, Env) of
        {_, V} ->
            V;
        false ->
            io:fwrite("No version specified~n", []),
            "1"
    end.

write_to_file(F, Terms) ->
    io:fwrite("write_to_file(~p, ~p)~n", [F, Terms]),
    {ok, Fd} = file:open(F, [write]),
    try
        [io:fwrite(Fd, "~p.~n~n", [T]) || T <- Terms]
    after
        file:close(Fd)
    end.

replace_rels(Ts, Env) ->
    lists:flatmap(
      fun({rel,R,V,_} = T) ->
              case [As || {rel_apps,Rx,As} <- Env,
                          Rx == R] of
                  [] ->
                      [T];
		  [As1] ->
                      [{rel,R,V,As1},
                       {rel,R++"_setup",V,setup_conv(As1)}]
              end;
         (T) ->
              [T]
      end, Ts).

fix_lib_dirs(Apps, Ps) ->
    ActualLibs = [normalize_fname(D) || D <- ["../deps",
                                              "../lib"]],
    lists:keystore(lib_dirs, 1, Ps, {lib_dirs, ActualLibs}).

normalize_fname(F) ->
    filename:absname(filename:join(normalize_fname_(filename:split(F)))).

normalize_fname_([_D, ".."|T]) ->
    normalize_fname_(T);
normalize_fname_([H|T]) ->
    [H|normalize_fname_(T)];
normalize_fname_([]) ->
    [].



is_legal_dir(D) ->
    case file:list_dir(D) of
        {error, _} ->
            io:fwrite("NOTE: Dir can't be read: ~s~n", [D]),
            false;
        {ok,_} ->
            true
    end.

app_name(A) when is_tuple(A) ->
    element(1, A);
app_name(A) when is_atom(A) ->
    A.

fix_apps([{app, exodm, Opts}|T]) ->
    [{app, exodm, [{lib_dir, exodm_lib_dir()}|Opts]}|fix_apps(T)];
fix_apps([{app, A, Opts}|T]) ->
    [{app, A, [{lib_dir, code:lib_dir(A)}|Opts]}|fix_apps(T)];
fix_apps([H|T]) ->
    [H|fix_apps(T)];
fix_apps([]) ->
    [].

setup_conv(As) ->
    lists:map(
      fun(setup) -> setup;
         ({setup,load}) -> setup;
         (A) when A==kernel; A==stdlib; A==sasl ->
              A;
         (A) when is_atom(A) ->
              {A, load};
         ({A,Is}) when is_list(Is) ->
              {A, load, Is};
         ({A,T}) when is_atom(T) ->
              {A, load};
         ({A,T,Is}) when is_atom(T), is_list(Is) ->
              {A, load, Is}
      end, As).

otp_libdir() ->
    filename:dirname(code:lib_dir(stdlib)).

store(X, X, L) ->
    L;
store(X, _, L) ->
    case lists:member(X, L) of
        true ->
            L;
        false ->
            L ++ [X]
    end.

exodm_lib_dir() ->
    {ok, CWD} = file:get_cwd(),
    filename:dirname(CWD).