2009-11-29 23:44:30 +00:00
|
|
|
%% -------------------------------------------------------------------
|
|
|
|
%%
|
|
|
|
%% rebar: Erlang Build Tools
|
|
|
|
%%
|
|
|
|
%% Copyright (c) 2009 Dave Smith (dizzyd@dizzyd.com)
|
|
|
|
%%
|
|
|
|
%% Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
%% of this software and associated documentation files (the "Software"), to deal
|
|
|
|
%% in the Software without restriction, including without limitation the rights
|
|
|
|
%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
%% copies of the Software, and to permit persons to whom the Software is
|
|
|
|
%% furnished to do so, subject to the following conditions:
|
|
|
|
%%
|
|
|
|
%% The above copyright notice and this permission notice shall be included in
|
|
|
|
%% all copies or substantial portions of the Software.
|
|
|
|
%%
|
|
|
|
%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
%% THE SOFTWARE.
|
|
|
|
%% -------------------------------------------------------------------
|
|
|
|
-module(rebar_core).
|
|
|
|
|
|
|
|
-export([run/1]).
|
|
|
|
|
2009-11-29 23:53:53 +00:00
|
|
|
-include("rebar.hrl").
|
|
|
|
|
2009-11-29 23:44:30 +00:00
|
|
|
%% ===================================================================
|
|
|
|
%% Public API
|
|
|
|
%% ===================================================================
|
|
|
|
|
2009-12-02 12:15:35 +00:00
|
|
|
run(Args) ->
|
2009-11-29 23:44:30 +00:00
|
|
|
%% Filter all the flags (i.e. string of form key=value) from the
|
|
|
|
%% command line arguments. What's left will be the commands to run.
|
|
|
|
Commands = filter_flags(Args, []),
|
|
|
|
|
|
|
|
%% Pre-load the rebar app so that we get default configuration
|
|
|
|
application:load(rebar),
|
|
|
|
|
|
|
|
%% Initialize logging system
|
|
|
|
rebar_log:init(),
|
|
|
|
|
|
|
|
%% From the current working directory, search recursively and find
|
|
|
|
%% all the application and release directories. We always terminate the
|
|
|
|
%% recursion at an application or release directory.
|
|
|
|
Cwd = rebar_utils:get_cwd(),
|
|
|
|
case target_type(Cwd) of
|
|
|
|
undefined ->
|
|
|
|
Targets = find_targets(Cwd);
|
|
|
|
{Type, Filename} ->
|
|
|
|
Targets = [{Type, Cwd, Filename}]
|
|
|
|
end,
|
|
|
|
|
|
|
|
%% Prefix all the app targets to the code path so that inter-app compilation
|
|
|
|
%% works properly
|
|
|
|
update_code_path(Targets),
|
|
|
|
|
|
|
|
%% Finally, apply the specified command to each target
|
2009-11-29 23:53:53 +00:00
|
|
|
apply_commands(Targets, Commands).
|
2009-11-29 23:44:30 +00:00
|
|
|
|
|
|
|
|
|
|
|
%% ===================================================================
|
|
|
|
%% Internal functions
|
|
|
|
%% ===================================================================
|
|
|
|
|
|
|
|
%%
|
|
|
|
%% Seperate all commands (single-words) from flags (key=value) and store
|
|
|
|
%% values into the rebar_config global storage.
|
|
|
|
%%
|
|
|
|
filter_flags([], Commands) ->
|
|
|
|
lists:reverse(Commands);
|
|
|
|
filter_flags([Item | Rest], Commands) ->
|
|
|
|
case string:tokens(Item, "=") of
|
|
|
|
[Command] ->
|
|
|
|
filter_flags(Rest, [Command | Commands]);
|
|
|
|
[KeyStr, Value] ->
|
|
|
|
Key = list_to_atom(KeyStr),
|
|
|
|
rebar_config:set_global(Key, Value),
|
|
|
|
filter_flags(Rest, Commands);
|
|
|
|
Other ->
|
|
|
|
?CONSOLE("Ignoring command line argument: ~p\n", [Other]),
|
|
|
|
filter_flags(Rest, Commands)
|
|
|
|
end.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
%%
|
|
|
|
%% Recursively find all the targets starting at a root directory
|
|
|
|
%%
|
|
|
|
find_targets(Root) ->
|
|
|
|
{ok, Files} = file:list_dir(Root),
|
|
|
|
find_targets(Files, Root, [], 1).
|
|
|
|
|
|
|
|
find_targets([], _Root, Acc, _Depth) ->
|
|
|
|
Acc;
|
|
|
|
find_targets(_Files, _Root, Acc, 10) ->
|
|
|
|
Acc;
|
|
|
|
find_targets([F | Rest], Root, Acc, Depth) ->
|
|
|
|
AbsName = filename:join([Root, F]),
|
2009-12-02 12:15:35 +00:00
|
|
|
?DEBUG("find_targets ~s ~s\n", [Root, F]),
|
2009-11-29 23:44:30 +00:00
|
|
|
case target_type(AbsName) of
|
|
|
|
undefined ->
|
|
|
|
case filelib:is_dir(AbsName) of
|
|
|
|
true ->
|
|
|
|
{ok, SubFiles} = file:list_dir(AbsName),
|
|
|
|
Acc2 = find_targets(SubFiles, AbsName, Acc, Depth+1);
|
|
|
|
false ->
|
|
|
|
Acc2 = Acc
|
|
|
|
end;
|
|
|
|
{Type, Filename} ->
|
|
|
|
Acc2 = [{Type, AbsName, Filename} | Acc]
|
|
|
|
end,
|
|
|
|
find_targets(Rest, Root, Acc2, Depth).
|
|
|
|
|
|
|
|
%%
|
|
|
|
%% Determine the target type of a given file: app, rel or undefined
|
|
|
|
%%
|
|
|
|
target_type(AbsName) ->
|
|
|
|
case rebar_app_utils:is_app_dir(AbsName) of
|
|
|
|
{true, AppFile} ->
|
|
|
|
{app, AppFile};
|
|
|
|
false ->
|
|
|
|
case rebar_rel_utils:is_rel_dir(AbsName) of
|
2009-12-02 12:15:35 +00:00
|
|
|
{true, ReltoolFile} ->
|
|
|
|
{rel, ReltoolFile};
|
2009-11-29 23:44:30 +00:00
|
|
|
false ->
|
|
|
|
undefined
|
|
|
|
end
|
|
|
|
end.
|
|
|
|
|
|
|
|
|
|
|
|
%%
|
|
|
|
%% Add all application targets to the front of the code path
|
|
|
|
%%
|
|
|
|
update_code_path([]) ->
|
|
|
|
ok;
|
|
|
|
update_code_path([{app, Dir, _} | Rest]) ->
|
|
|
|
EbinDir = filename:join([Dir, "ebin"]),
|
|
|
|
true = code:add_patha(EbinDir),
|
2009-12-02 12:15:35 +00:00
|
|
|
?DEBUG("Adding ~s to code path\n", [EbinDir]),
|
2009-11-29 23:44:30 +00:00
|
|
|
update_code_path(Rest);
|
|
|
|
update_code_path([_ | Rest]) ->
|
|
|
|
update_code_path(Rest).
|
|
|
|
|
|
|
|
|
|
|
|
apply_commands(_Targets, []) ->
|
|
|
|
ok;
|
|
|
|
apply_commands(Targets, [CommandStr | Rest]) ->
|
|
|
|
%% Convert the command into an atom for convenience
|
|
|
|
Command = list_to_atom(CommandStr),
|
|
|
|
|
2009-12-02 12:15:35 +00:00
|
|
|
case catch(apply_command(Targets, Command)) of
|
2009-11-29 23:44:30 +00:00
|
|
|
ok ->
|
|
|
|
apply_commands(Targets, Rest);
|
|
|
|
Other ->
|
|
|
|
Other
|
|
|
|
end.
|
|
|
|
|
|
|
|
apply_command([], _Command) ->
|
|
|
|
ok;
|
|
|
|
apply_command([{Type, Dir, File} | Rest], Command) ->
|
|
|
|
ok = file:set_cwd(Dir),
|
|
|
|
Config = rebar_config:new(Dir),
|
|
|
|
|
2009-12-02 03:34:18 +00:00
|
|
|
%% Look for subdirs configuration list -- if it exists, we're going to process those first
|
|
|
|
case subdirs(rebar_config:get_list(Config, subdirs, []), []) of
|
|
|
|
[] ->
|
|
|
|
ok;
|
|
|
|
Subdirs ->
|
2009-12-02 12:15:35 +00:00
|
|
|
?DEBUG("Subdirs: ~p\n", [Subdirs]),
|
2009-12-02 03:34:18 +00:00
|
|
|
update_code_path(Subdirs),
|
|
|
|
case apply_command(Subdirs, Command) of
|
|
|
|
ok ->
|
|
|
|
ok = file:set_cwd(Dir);
|
|
|
|
error ->
|
|
|
|
?FAIL
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
|
2009-11-29 23:44:30 +00:00
|
|
|
|
|
|
|
%% Pull the list of modules that are associated with Type operations. Each module
|
|
|
|
%% will be inspected for a function matching Command and if found, will execute that.
|
2009-12-02 12:15:35 +00:00
|
|
|
Modules = select_modules(rebar_config:get_modules(Config, Type), Command, []),
|
|
|
|
case Modules of
|
|
|
|
[] ->
|
|
|
|
%% None of the modules implement the command; move on to next target
|
2009-11-29 23:44:30 +00:00
|
|
|
apply_command(Rest, Command);
|
2009-12-02 12:15:35 +00:00
|
|
|
_ ->
|
|
|
|
%% Provide some info on where we are
|
|
|
|
?CONSOLE("==> ~s (~s)\n", [filename:basename(Dir), Command]),
|
|
|
|
|
|
|
|
%% Run the available modules
|
|
|
|
case catch(run_modules(Modules, Command, Config, File)) of
|
|
|
|
ok ->
|
|
|
|
apply_command(Rest, Command);
|
2009-12-03 16:41:10 +00:00
|
|
|
{error, failed} ->
|
|
|
|
error;
|
2009-12-02 12:15:35 +00:00
|
|
|
Other ->
|
|
|
|
?ERROR("~p failed while processing ~s: ~p", [Command, Dir, Other]),
|
|
|
|
error
|
|
|
|
end
|
2009-11-29 23:44:30 +00:00
|
|
|
end.
|
|
|
|
|
2009-12-02 03:34:18 +00:00
|
|
|
|
2009-11-29 23:44:30 +00:00
|
|
|
|
2009-12-02 12:15:35 +00:00
|
|
|
subdirs(Dirs, Acc) ->
|
|
|
|
lists:reverse(find_targets(Dirs, rebar_utils:get_cwd(), [], 1)).
|
|
|
|
|
|
|
|
select_modules([], _Command, Acc) ->
|
|
|
|
lists:reverse(Acc);
|
|
|
|
select_modules([Module | Rest], Command, Acc) ->
|
|
|
|
Exports = Module:module_info(exports),
|
|
|
|
case lists:member({Command, 2}, Exports) of
|
|
|
|
true ->
|
|
|
|
select_modules(Rest, Command, [Module | Acc]);
|
|
|
|
false ->
|
|
|
|
select_modules(Rest, Command, Acc)
|
|
|
|
end.
|
|
|
|
|
2009-11-29 23:44:30 +00:00
|
|
|
run_modules([], _Command, _Config, _File) ->
|
|
|
|
ok;
|
|
|
|
run_modules([Module | Rest], Command, Config, File) ->
|
2009-12-02 12:15:35 +00:00
|
|
|
case Module:Command(Config, File) of
|
2009-11-29 23:44:30 +00:00
|
|
|
ok ->
|
|
|
|
run_modules(Rest, Command, Config, File);
|
|
|
|
{error, Reason} ->
|
|
|
|
{error, Reason}
|
|
|
|
end.
|