summaryrefslogtreecommitdiff
path: root/bootstrap
blob: ba8dda27586f9238717142d6ff1a96484e0e12c6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#!/usr/bin/env escript
%% -*- mode: erlang;erlang-indent-level: 4;indent-tabs-mode: nil -*-
%% ex: ft=erlang ts=4 sw=4 et

main(Args) ->
    %% Get a string repr of build time
    Built = build_time(),

    %% Get a string repr of first matching VCS changeset
    VcsInfo = vcs_info([{hg, ".hg", "hg identify -i"},
                        {git, ".git", "git describe --always"}]),

    %% Check for force=1 flag to force a rebuild
    case lists:member("force=1", Args) of
        true ->
            rm("ebin/*.beam");
        false ->
            rm("ebin/rebar_core.beam")
    end,

    %% Add check for debug flag
    DebugFlag = case lists:member("debug", Args) of
                    true -> debug_info;
                    false -> undefined
                end,

    %% Compile all src/*.erl to ebin
    case make:files(filelib:wildcard("src/*.erl"),
                    [{outdir, "ebin"}, {i, "include"},
                     DebugFlag,
                     {d, 'BUILD_TIME', Built},
                     {d, 'VCS_INFO', VcsInfo}]) of
        up_to_date ->
            ok;
        error ->
            io:format("Failed to compile rebar files!\n"),
            halt(1)
    end,

    %% Make sure file:consult can parse the .app file
    case file:consult("ebin/rebar.app") of
        {ok, _} ->
            ok;
        {error, Reason} ->
            io:format("Invalid syntax in ebin/rebar.app: ~p\n", [Reason]),
            halt(1)
    end,

    %% Add ebin/ to our path
    true = code:add_path("ebin"),

    %% Run rebar to do proper .app validation and such
    rebar:main(["compile"] ++ Args),

    %% Read the contents of the files in ebin and templates; note that we
    %% place all the beam files at the top level of the code archive so
    %% that code loading works properly.
    Files = load_files("*", "ebin") ++ load_files("priv/templates/*", "."),

    case zip:create("mem", Files, [memory]) of
        {ok, {"mem", ZipBin}} ->
            %% Archive was successfully created. Prefix that binary with our
            %% header and write to "rebar" file.
            %% Without -noshell -noinput escript consumes all input that would
            %% otherwise go to the shell for the next command.
            Script = <<"#!/usr/bin/env escript\n%%! -noshell -noinput\n",
                       ZipBin/binary>>,
            case file:write_file("rebar", Script) of
                ok ->
                    ok;
                {error, WriteError} ->
                    io:format("Failed to write rebar script: ~p\n",
                              [WriteError]),
                    halt(1)
            end;
        {error, ZipError} ->
            io:format("Failed to construct rebar script archive: ~p\n",
                      [ZipError]),
            halt(1)
    end,

    %% Finally, update executable perms for our script on *nix,
    %%  or write out script files on win32.
    case os:type() of
        {unix,_} ->
            [] = os:cmd("chmod u+x rebar"),
            ok;
        {win32,_} ->
            write_windows_scripts(),
            ok;
        _ ->
            ok
    end,

    %% Add a helpful message
    io:format("Congratulations! You now have a self-contained script called"
              " \"rebar\" in\n"
              "your current working directory. "
              "Place this script anywhere in your path\n"
              "and you can use rebar to build OTP-compliant apps.\n").

rm(Path) ->
    NativePath = filename:nativename(Path),
    Cmd = case os:type() of
              {unix,_} -> "rm -f ";
              {win32,_} -> "del /q "
          end,
    [] = os:cmd(Cmd ++ NativePath),
    ok.

build_time() ->
    {{Y, M, D}, {H, Min, S}} = calendar:now_to_universal_time(now()),
    lists:flatten(io_lib:format("~4..0w~2..0w~2..0w_~2..0w~2..0w~2..0w",
                                [Y, M, D, H, Min, S])).


load_files(Wildcard, Dir) ->
    [read_file(Filename, Dir) || Filename <- filelib:wildcard(Wildcard, Dir)].

read_file(Filename, Dir) ->
    {ok, Bin} = file:read_file(filename:join(Dir, Filename)),
    {Filename, Bin}.

vcs_info([]) ->
    "No VCS info available.";
vcs_info([{Id, Dir, Cmd} | Rest]) ->
    case filelib:is_dir(Dir) of
        true ->
            lists:concat([Id, " ", string:strip(os:cmd(Cmd), both, $\n)]);
        false ->
            vcs_info(Rest)
    end.

write_windows_scripts() ->
    PowershellScript=
        "$basedir = Split-Path -Parent $MyInvocation.MyCommand.Path\r\n"
        "$rebar = Join-Path $basedir \"rebar\"\r\n"
        "escript.exe $rebar $args\r\n",
    CmdScript=
        "@echo off\r\n"
        "setlocal\r\n"
        "set rebarscript=%~f0\r\n"
        "escript.exe \"%rebarscript:.cmd=%\" %*\r\n",
    ok = file:write_file("rebar.cmd", CmdScript),
    UTF16BE = {utf16, big},
    ok = file:write_file("rebar.ps1",
                         [unicode:encoding_to_bom(UTF16BE),
                          unicode:characters_to_binary(PowershellScript,
                                                       utf8, UTF16BE)]).