From 28fe3bfd54390a4ea74156b5f182d59f69d32331 Mon Sep 17 00:00:00 2001
From: Dave Smith <dizzyd@dizzyd.com>
Date: Sun, 29 Nov 2009 16:44:30 -0700
Subject: More gross structural work; now has log levels and broken out log
 level control

---
 priv/rebar | 137 +------------------------------------------------------------
 1 file changed, 2 insertions(+), 135 deletions(-)

(limited to 'priv/rebar')

diff --git a/priv/rebar b/priv/rebar
index a9e229f..198f20d 100755
--- a/priv/rebar
+++ b/priv/rebar
@@ -28,138 +28,5 @@
 
 -include_lib("rebar/include/rebar.hrl").
 
-main(Commands) ->
-    %% Pre-load the rebar app so that we get default configuration
-    application:load(rebar),
-    
-    %% 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
-    apply_commands(Targets, Commands);
-main(_) ->
-    io:format("usage: rebar <command>...\n").
-
-
-%%
-%% 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]),
-    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
-                true ->
-                    {rel, ""};
-                false ->
-                    undefined
-            end
-    end.
-
-
-%%
-%% Given a command and target type, determine if the command is applicable
-%%
-valid_command(compile, app) -> true;
-valid_command(clean, _Any)  -> true;
-valid_command(_, _)         -> false.
-
-
-%%
-%% 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),
-    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),
-
-    %% Filter out all the targets, based on the specified command.
-    FilteredTargets = [{Type, Dir, Filename} || {Type, Dir, Filename} <- Targets,
-                                                valid_command(Command, Type) == true],
-    case apply_command(FilteredTargets, Command) of
-        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),
-
-    %% Provide some info on where we are
-    ?CONSOLE("==> ~s (~s)\n", [filename:basename(Dir), Command]),
-
-    %% 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. 
-    Modules = rebar_config:get_modules(Config, Type),
-    case catch(run_modules(Modules, Command, Config, File)) of
-        ok ->
-            apply_command(Rest, Command);
-        Other ->
-            ?CONSOLE("~p failed while processing ~s: ~p", [Command, Dir, Other])
-    end.
-
-
-run_modules([], _Command, _Config, _File) ->
-    ok;
-run_modules([Module | Rest], Command, Config, File) ->
-    case Module:Command(Config, File) of
-        ok ->
-            run_modules(Rest, Command, Config, File);
-        {error, Reason} ->
-            {error, Reason}
-    end.
+main(Args) ->
+    rebar_core:run(Args).
-- 
cgit v1.1