large refactoring

Removed separate compilers
Resolves apps to build
Finds avail deps before pulling/building
Includes relx
Simplifies build commands

1 files changed, 146 insertions, 709 deletions

diff --git a/src/rebar_deps.erl b/src/rebar_deps.erl
index bd94921..d9d0399 100644
--- a/src/rebar_deps.erl
+++ b/src/rebar_deps.erl
@@ -26,113 +26,109 @@
 %% -------------------------------------------------------------------
 -module(rebar_deps).
 
+-behaviour(rebar_provider).
+
+-export([init/1,
+         do/1]).
+
 -include("rebar.hrl").
 
--export([preprocess/2,
-         postprocess/2,
-         compile/2,
-         setup_env/1,
-         'check-deps'/2,
-         'get-deps'/2,
-         'update-deps'/2,
-         'delete-deps'/2,
-         'list-deps'/2]).
+-export([setup_env/1]).
 
 %% for internal use only
 -export([info/2]).
 -export([get_deps_dir/1]).
 
--record(dep, { dir,
-               app,
-               vsn_regex,
-               source,
-               is_raw }). %% is_raw = true means non-Erlang/OTP dependency
+-define(PROVIDER, deps).
+-define(DEPS, []).
 
 %% ===================================================================
 %% Public API
 %% ===================================================================
 
-preprocess(Config, _) ->
-    %% Side effect to set deps_dir globally for all dependencies from
-    %% top level down. Means the root deps_dir is honoured or the default
-    %% used globally since it will be set on the first time through here
-    Config1 = set_shared_deps_dir(Config, get_shared_deps_dir(Config, [])),
-
-    %% Get the list of deps for the current working directory and identify those
-    %% deps that are available/present.
-    Deps = rebar_config:get_local(Config1, deps, []),
-    {Config2, {AvailableDeps, MissingDeps}} = find_deps(Config1, find, Deps),
+-spec init(rebar_config:config()) -> {ok, rebar_config:config()}.
+init(State) ->
+    State1 = rebar_config:add_provider(State, #provider{name = ?PROVIDER,
+                                                        provider_impl = ?MODULE,
+                                                        provides = deps,
+                                                        bare = false,
+                                                        deps = ?DEPS,
+                                                        example = "rebar deps",
+                                                        short_desc = "",
+                                                        desc = "",
+                                                        opts = []}),
+    {ok, State1}.
+
+-spec do(rebar_config:config()) -> {ok, rebar_config:config()} | relx:error().
+do(Config) ->
+    Deps = rebar_config:get_local(Config, deps, []),
+    Goals = lists:map(fun({Name, "", _}) ->
+                              Name;
+                         ({Name, ".*", _}) ->
+                              Name;
+                         ({Name, Vsn, _}) ->
+                              {Name, Vsn}
+                      end, Deps),
 
-    ?DEBUG("Available deps: ~p\n", [AvailableDeps]),
-    ?DEBUG("Missing deps  : ~p\n", [MissingDeps]),
+    {Config1, Deps1} = update_deps(Config, Deps),
+    Config2 = rebar_config:deps(Config1, Deps1),
 
-    %% Add available deps to code path
-    Config3 = update_deps_code_path(Config2, AvailableDeps),
+    {ok, rebar_config:goals(Config2, Goals)}.
 
-    %% Filtering out 'raw' dependencies so that no commands other than
-    %% deps-related can be executed on their directories.
-    NonRawAvailableDeps = [D || D <- AvailableDeps, not D#dep.is_raw],
+update_deps(Config, Deps) ->
+    DepsDir = get_deps_dir(Config),
 
-    case rebar_config:get_xconf(Config, current_command, undefined) of
-        'update-deps' ->
-            %% Skip ALL of the dep folders, we do this because we don't want
-            %% any other calls to preprocess() for update-deps beyond the
-            %% toplevel directory. They aren't actually harmful, but they slow
-            %% things down unnecessarily.
-            NewConfig = lists:foldl(
-                          fun(D, Acc) ->
-                                  rebar_config:set_skip_dir(Acc, D#dep.dir)
-                          end,
-                          Config3,
-                          collect_deps(rebar_utils:get_cwd(), Config3)),
-            %% Return the empty list, as we don't want anything processed before
-            %% us.
-            {ok, NewConfig, []};
-        _ ->
-            %% If skip_deps=true, mark each dep dir as a skip_dir w/ the core
-            %% so that the current command doesn't run on the dep dir.
-            %% However, pre/postprocess WILL run (and we want it to) for
-            %% transitivity purposes.
-            %%
-            %% Also, if skip_deps=comma,separated,app,list, then only the given
-            %% dependencies are skipped.
-            NewConfig =
-                case rebar_config:get_global(Config3, skip_deps, false) of
-                    "true" ->
-                        lists:foldl(
-                          fun(#dep{dir = Dir}, C) ->
-                                  rebar_config:set_skip_dir(C, Dir)
-                          end, Config3, AvailableDeps);
-                    Apps when is_list(Apps) ->
-                        SkipApps = [list_to_atom(App) ||
-                                       App <- string:tokens(Apps, ",")],
-                        lists:foldl(
-                          fun(#dep{dir = Dir, app = App}, C) ->
-                                  case lists:member(App, SkipApps) of
-                                      true -> rebar_config:set_skip_dir(C, Dir);
-                                      false -> C
-                                  end
-                          end, Config3, AvailableDeps);
-                    _ ->
-                        Config3
-                end,
+    %% Find available apps to fulfill dependencies
+    FoundApps = rebar_app_discover:find_apps([DepsDir]),
 
-            %% Return all the available dep directories for process
-            {ok, NewConfig, dep_dirs(NonRawAvailableDeps)}
-    end.
+    %% Resolve deps and their dependencies
+    Deps1 = handle_deps(Deps, FoundApps),
 
-postprocess(Config, _) ->
-    case rebar_config:get_xconf(Config, ?MODULE, undefined) of
-        undefined ->
-            {ok, []};
-        Dirs ->
-            NewConfig = rebar_config:erase_xconf(Config, ?MODULE),
-            {ok, NewConfig, Dirs}
+    case download_missing_deps(Config, DepsDir, FoundApps, Deps1) of
+        {Config1, []} ->
+            {Config1, Deps1};
+        {Config1, _} ->
+            update_deps(Config1, Deps1)
     end.
 
-compile(Config, _) ->
-    {Config1, _AvailDeps} = do_check_deps(Config),
-    {ok, Config1}.
+handle_deps(Deps, Found) ->
+    NewDeps =
+        lists:foldl(fun(X, DepsAcc) ->
+                            C = rebar_config:new2(rebar_config:new(), rebar_app_info:dir(X)),
+                            LocalDeps = rebar_config:get_local(C, deps, []),
+                            [LocalDeps | DepsAcc]
+                    end, [], Found),
+    NewDeps1 = lists:flatten(NewDeps),
+
+    %% Weed out duplicates
+    lists:umerge(fun(A, B) ->
+                         element(1, A) =:= element(1, B)
+                 end, lists:usort(Deps), lists:usort(NewDeps1)).
+
+download_missing_deps(Config, DepsDir, Found, Deps) ->
+    Apps = rebar_config:apps_to_build(Config),
+    Missing = lists:filter(fun(X) ->
+                               not lists:any(fun(F) ->
+                                                     element(1, X) =:= element(2, F)
+                                             end, Found++Apps)
+                       end, Deps),
+    ec_plists:foreach(fun(X) ->
+                              TargetDir = get_deps_dir(DepsDir, element(1, X)),
+                              case filelib:is_dir(TargetDir) of
+                                  true ->
+                                      ok;
+                                  false ->
+                                      rebar_fetch:download_source(TargetDir, element(3, X))
+                              end
+                      end, Missing),
+
+    Config1 = lists:foldl(fun(X, ConfigAcc) ->
+                                  TargetDir = get_deps_dir(DepsDir, element(1, X)),
+                                  [AppSrc] = rebar_app_discover:find_apps([TargetDir]),
+                                  rebar_config:add_dep(ConfigAcc, AppSrc)
+                          end, Config, Missing),
+
+    {Config1, Missing}.
 
 %% set REBAR_DEPS_DIR and ERL_LIBS environment variables
 setup_env(Config) ->
@@ -152,99 +148,77 @@ setup_env(Config) ->
                end,
     [{"REBAR_DEPS_DIR", DepsDir}, ERL_LIBS].
 
-%% common function used by 'check-deps' and 'compile'
-do_check_deps(Config) ->
-    %% Get the list of immediate (i.e. non-transitive) deps that are missing
-    Deps = rebar_config:get_local(Config, deps, []),
-    case find_deps(Config, find, Deps) of
-        {Config1, {AvailDeps, []}} ->
-            %% No missing deps
-            {Config1, AvailDeps};
-        {_Config1, {_, MissingDeps}} ->
-            lists:foreach(fun (#dep{app=App, vsn_regex=Vsn, source=Src}) ->
-                                  ?CONSOLE("Dependency not available: "
-                                           "~p-~s (~p)\n", [App, Vsn, Src])
-                          end, MissingDeps),
-            ?FAIL
-    end.
-
-'check-deps'(Config, _) ->
-    {Config1, AvailDeps} = do_check_deps(Config),
-    {ok, save_dep_dirs(Config1, AvailDeps)}.
-
-'get-deps'(Config, _) ->
-    %% Determine what deps are available and missing
-    Deps = rebar_config:get_local(Config, deps, []),
-    {Config1, {_AvailableDeps, MissingDeps}} = find_deps(Config, find, Deps),
-    MissingDeps1 = [D || D <- MissingDeps, D#dep.source =/= undefined],
 
-    %% For each missing dep with a specified source, try to pull it.
-    {Config2, PulledDeps} =
-        lists:foldl(fun(D, {C, PulledDeps0}) ->
-                            {C1, D1} = use_source(C, D),
-                            {C1, [D1 | PulledDeps0]}
-                    end, {Config1, []}, MissingDeps1),
-
-    %% Add each pulled dep to our list of dirs for post-processing. This yields
-    %% the necessary transitivity of the deps
-    {ok, save_dep_dirs(Config2, lists:reverse(PulledDeps))}.
-
-'update-deps'(Config, _) ->
-    Config1 = rebar_config:set_xconf(Config, depowner, dict:new()),
-    {Config2, UpdatedDeps} = update_deps_int(Config1, []),
-    DepOwners = rebar_config:get_xconf(Config2, depowner, dict:new()),
+get_deps_dir(Config) ->
+    BaseDir = rebar_utils:base_dir(Config),
+    get_deps_dir(BaseDir, "deps").
 
-    %% check for conflicting deps
-    _ = [?ERROR("Conflicting dependencies for ~p: ~p~n",
-                [K, [{"From: " ++ string:join(dict:fetch(D, DepOwners), ", "),
-                      {D#dep.vsn_regex, D#dep.source}} || D <- V]])
-         || {K, V} <- dict:to_list(
-                        lists:foldl(
-                          fun(Dep, Acc) ->
-                                  dict:append(Dep#dep.app, Dep, Acc)
-                          end, dict:new(), UpdatedDeps)),
-            length(V) > 1],
+%% ===================================================================
+%% Internal functions
+%% ===================================================================
 
-    %% Add each updated dep to our list of dirs for post-processing. This yields
-    %% the necessary transitivity of the deps
-    {ok, save_dep_dirs(Config, UpdatedDeps)}.
+get_deps_dir(DepsDir, App) ->
+    filename:join(DepsDir, App).
+
+-spec gather_application_info(file:name(), file:filename()) ->
+                                     {ok, rebar_app_info:t()} |
+                                     {warning, Reason::term()} |
+                                     {error, Reason::term()}.
+gather_application_info(EbinDir, File) ->
+    AppDir = filename:dirname(EbinDir),
+    case file:consult(File) of
+        {ok, [{application, AppName, AppDetail}]} ->
+            validate_application_info(EbinDir, File, AppName, AppDetail);
+        {error, Reason} ->
+            {warning, {unable_to_load_app, AppDir, Reason}};
+        _ ->
+            {warning, {invalid_app_file, File}}
+    end.
 
-'delete-deps'(Config, _) ->
-    %% Delete all the available deps in our deps/ directory, if any
-    {true, DepsDir} = get_deps_dir(Config),
-    Deps = rebar_config:get_local(Config, deps, []),
-    {Config1, {AvailableDeps, _}} = find_deps(Config, find, Deps),
-    _ = [delete_dep(D)
-         || D <- AvailableDeps,
-            lists:prefix(DepsDir, D#dep.dir)],
-    {ok, Config1}.
+-spec validate_application_info(file:name(),
+                                file:name(),
+                                atom(),
+                                proplists:proplist()) ->
+                                       {ok, list()} |
+                                       {warning, Reason::term()} |
+                                       {error, Reason::term()}.
+validate_application_info(EbinDir, AppFile, AppName, AppDetail) ->
+    AppDir = filename:dirname(EbinDir),
+    case get_modules_list(AppFile, AppDetail) of
+        {ok, List} ->
+            has_all_beams(EbinDir, List);
+        Error ->
+            Error
+    end.
 
-'list-deps'(Config, _) ->
-    Deps = rebar_config:get_local(Config, deps, []),
-    case find_deps(Config, find, Deps) of
-        {Config1, {AvailDeps, []}} ->
-            lists:foreach(fun(Dep) -> print_source(Dep) end, AvailDeps),
-            {ok, save_dep_dirs(Config1, AvailDeps)};
-        {_, MissingDeps} ->
-            ?ABORT("Missing dependencies: ~p\n", [MissingDeps])
+-spec get_modules_list(file:name(), proplists:proplist()) ->
+                              {ok, list()} |
+                              {warning, Reason::term()} |
+                              {error, Reason::term()}.
+get_modules_list(AppFile, AppDetail) ->
+    case proplists:get_value(modules, AppDetail) of
+        undefined ->
+            {warning, {invalid_app_file, AppFile}};
+        ModulesList ->
+            {ok, ModulesList}
     end.
 
-%% ===================================================================
-%% Internal functions
-%% ===================================================================
+-spec has_all_beams(file:name(), list()) ->
+                           ok | {error, Reason::term()}.
+has_all_beams(EbinDir, [Module | ModuleList]) ->
+    BeamFile = filename:join([EbinDir,
+                              list_to_binary(atom_to_list(Module) ++ ".beam")]),
+    case filelib:is_file(BeamFile) of
+        true ->
+            has_all_beams(EbinDir, ModuleList);
+        false ->
+            {warning, {missing_beam_file, Module, BeamFile}}
+    end;
+has_all_beams(_, []) ->
+    ok.
 
-info(help, compile) ->
-    info_help("Display to be fetched dependencies");
-info(help, 'check-deps') ->
-    info_help("Display to be fetched dependencies");
-info(help, 'get-deps') ->
-    info_help("Fetch dependencies");
-info(help, 'update-deps') ->
-    info_help("Update fetched dependencies");
-info(help, 'delete-deps') ->
-    info_help("Delete fetched dependencies");
-info(help, 'list-deps') ->
-    info_help("List dependencies").
+info(help, 'deps') ->
+    info_help("Display dependencies").
 
 info_help(Description) ->
     ?CONSOLE(
@@ -281,540 +255,3 @@ info_help(Description) ->
           {app_name, ".*", {fossil, "https://www.example.org/url", "Vsn"}},
           {app_name, ".*", {p4, "//depot/subdir/app_dir"}}]}
        ]).
-
-%% Added because of trans deps,
-%% need all deps in same dir and should be the one set by the root rebar.config
-%% In case one is given globally, it has higher priority
-%% Sets a default if root config has no deps_dir set
-set_shared_deps_dir(Config, []) ->
-    LocalDepsDir = rebar_config:get_local(Config, deps_dir, "deps"),
-    GlobalDepsDir = rebar_config:get_global(Config, deps_dir, LocalDepsDir),
-    DepsDir = case os:getenv("REBAR_DEPS_DIR") of
-                  false ->
-                      GlobalDepsDir;
-                  Dir ->
-                      Dir
-              end,
-    rebar_config:set_xconf(Config, deps_dir, DepsDir);
-set_shared_deps_dir(Config, _DepsDir) ->
-    Config.
-
-get_shared_deps_dir(Config, Default) ->
-    rebar_config:get_xconf(Config, deps_dir, Default).
-
-get_deps_dir(Config) ->
-    get_deps_dir(Config, "").
-
-get_deps_dir(Config, App) ->
-    BaseDir = rebar_utils:base_dir(Config),
-    DepsDir = get_shared_deps_dir(Config, "deps"),
-    {true, filename:join([BaseDir, DepsDir, App])}.
-
-dep_dirs(Deps) ->
-    [D#dep.dir || D <- Deps].
-
-save_dep_dirs(Config, Deps) ->
-    rebar_config:set_xconf(Config, ?MODULE, dep_dirs(Deps)).
-
-get_lib_dir(App) ->
-    %% Find App amongst the reachable lib directories
-    %% Returns either the found path or a tagged tuple with a boolean
-    %% to match get_deps_dir's return type
-    case code:lib_dir(App) of
-        {error, bad_name} -> {false, bad_name};
-        Path -> {true, Path}
-    end.
-
-update_deps_code_path(Config, []) ->
-    Config;
-update_deps_code_path(Config, [Dep | Rest]) ->
-    Config2 =
-        case is_app_available(Config, Dep#dep.app,
-                              Dep#dep.vsn_regex, Dep#dep.dir, Dep#dep.is_raw) of
-            {Config1, {true, _}} ->
-                Dir = filename:join(Dep#dep.dir, "ebin"),
-                ok = filelib:ensure_dir(filename:join(Dir, "dummy")),
-                ?DEBUG("Adding ~s to code path~n", [Dir]),
-                true = code:add_patha(Dir),
-                Config1;
-            {Config1, {false, _}} ->
-                Config1
-        end,
-    update_deps_code_path(Config2, Rest).
-
-find_deps(Config, find=Mode, Deps) ->
-    find_deps(Config, Mode, Deps, {[], []});
-find_deps(Config, read=Mode, Deps) ->
-    find_deps(Config, Mode, Deps, []).
-
-find_deps(Config, find, [], {Avail, Missing}) ->
-    {Config, {lists:reverse(Avail), lists:reverse(Missing)}};
-find_deps(Config, read, [], Deps) ->
-    {Config, lists:reverse(Deps)};
-find_deps(Config, Mode, [App | Rest], Acc) when is_atom(App) ->
-    find_deps(Config, Mode, [{App, ".*", undefined} | Rest], Acc);
-find_deps(Config, Mode, [{App, VsnRegex} | Rest], Acc) when is_atom(App) ->
-    find_deps(Config, Mode, [{App, VsnRegex, undefined} | Rest], Acc);
-find_deps(Config, Mode, [{App, VsnRegex, Source} | Rest], Acc) ->
-    find_deps(Config, Mode, [{App, VsnRegex, Source, []} | Rest], Acc);
-find_deps(Config, Mode, [{App, VsnRegex, Source, Opts} | Rest], Acc)
-  when is_list(Opts) ->
-    Dep = #dep { app = App,
-                 vsn_regex = VsnRegex,
-                 source = Source,
-                 %% dependency is considered raw (i.e. non-Erlang/OTP) when
-                 %% 'raw' option is present
-                 is_raw = proplists:get_value(raw, Opts, false) },
-    {Config1, {Availability, FoundDir}} = find_dep(Config, Dep),
-    find_deps(Config1, Mode, Rest,
-              acc_deps(Mode, Availability, Dep, FoundDir, Acc));
-find_deps(_Config, _Mode, [Other | _Rest], _Acc) ->
-    ?ABORT("Invalid dependency specification ~p in ~s\n",
-           [Other, rebar_utils:get_cwd()]).
-
-find_dep(Config, Dep) ->
-    %% Find a dep based on its source,
-    %% e.g. {git, "https://github.com/mochi/mochiweb.git", "HEAD"}
-    %% Deps with a source must be found (or fetched) locally.
-    %% Those without a source may be satisfied from lib dir (get_lib_dir).
-    find_dep(Config, Dep, Dep#dep.source).
-
-find_dep(Config, Dep, undefined) ->
-    %% 'source' is undefined.  If Dep is not satisfied locally,
-    %% go ahead and find it amongst the lib_dir's.
-    case find_dep_in_dir(Config, Dep, get_deps_dir(Config, Dep#dep.app)) of
-        {_Config1, {avail, _Dir}} = Avail ->
-            Avail;
-        {Config1, {missing, _}} ->
-            find_dep_in_dir(Config1, Dep, get_lib_dir(Dep#dep.app))
-    end;
-find_dep(Config, Dep, _Source) ->
-    %% _Source is defined.  Regardless of what it is, we must find it
-    %% locally satisfied or fetch it from the original source
-    %% into the project's deps
-    find_dep_in_dir(Config, Dep, get_deps_dir(Config, Dep#dep.app)).
-
-find_dep_in_dir(Config, _Dep, {false, Dir}) ->
-    {Config, {missing, Dir}};
-find_dep_in_dir(Config, Dep, {true, Dir}) ->
-    App = Dep#dep.app,
-    VsnRegex = Dep#dep.vsn_regex,
-    IsRaw = Dep#dep.is_raw,
-    case is_app_available(Config, App, VsnRegex, Dir, IsRaw) of
-        {Config1, {true, _AppFile}} -> {Config1, {avail, Dir}};
-        {Config1, {false, _}}       -> {Config1, {missing, Dir}}
-    end.
-
-acc_deps(find, avail, Dep, AppDir, {Avail, Missing}) ->
-    {[Dep#dep { dir = AppDir } | Avail], Missing};
-acc_deps(find, missing, Dep, AppDir, {Avail, Missing}) ->
-    {Avail, [Dep#dep { dir = AppDir } | Missing]};
-acc_deps(read, _, Dep, AppDir, Acc) ->
-    [Dep#dep { dir = AppDir } | Acc].
-
-delete_dep(D) ->
-    case filelib:is_dir(D#dep.dir) of
-        true ->
-            ?INFO("Deleting dependency: ~s\n", [D#dep.dir]),
-            rebar_file_utils:rm_rf(D#dep.dir);
-        false ->
-            ok
-    end.
-
-require_source_engine(Source) ->
-    true = source_engine_avail(Source),
-    ok.
-
-%% IsRaw = false means regular Erlang/OTP dependency
-%%
-%% IsRaw = true means non-Erlang/OTP dependency, e.g. the one that does not
-%% have a proper .app file
-is_app_available(Config, App, VsnRegex, Path, _IsRaw = false) ->
-    ?DEBUG("is_app_available, looking for App ~p with Path ~p~n", [App, Path]),
-    case rebar_app_utils:is_app_dir(Path) of
-        {true, AppFile} ->
-            case rebar_app_utils:app_name(Config, AppFile) of
-                {Config1, App} ->
-                    {Config2, Vsn} = rebar_app_utils:app_vsn(Config1, AppFile),
-                    ?INFO("Looking for ~s-~s ; found ~s-~s at ~s\n",
-                          [App, VsnRegex, App, Vsn, Path]),
-                    case re:run(Vsn, VsnRegex, [{capture, none}]) of
-                        match ->
-                            {Config2, {true, Path}};
-                        nomatch ->
-                            ?WARN("~s has version ~p; requested regex was ~s\n",
-                                  [AppFile, Vsn, VsnRegex]),
-                            {Config2,
-                             {false, {version_mismatch,
-                                      {AppFile,
-                                       {expected, VsnRegex}, {has, Vsn}}}}}
-                    end;
-                {Config1, OtherApp} ->
-                    ?WARN("~s has application id ~p; expected ~p\n",
-                          [AppFile, OtherApp, App]),
-                    {Config1,
-                     {false, {name_mismatch,
-                              {AppFile, {expected, App}, {has, OtherApp}}}}}
-            end;
-        false ->
-            ?WARN("Expected ~s to be an app dir (containing ebin/*.app), "
-                  "but no .app found.\n", [Path]),
-            {Config, {false, {missing_app_file, Path}}}
-    end;
-is_app_available(Config, App, _VsnRegex, Path, _IsRaw = true) ->
-    ?DEBUG("is_app_available, looking for Raw Depencency ~p with Path ~p~n",
-           [App, Path]),
-    case filelib:is_dir(Path) of
-        true ->
-            %% TODO: look for version string in <Path>/VERSION file? Not clear
-            %% how to detect git/svn/hg/{cmd, ...} settings that can be passed
-            %% to rebar_utils:vcs_vsn/2 to obtain version dynamically
-            {Config, {true, Path}};
-        false ->
-            ?WARN("Expected ~s to be a raw dependency directory, "
-                  "but no directory found.\n", [Path]),
-            {Config, {false, {missing_raw_dependency_directory, Path}}}
-    end.
-
-use_source(Config, Dep) ->
-    use_source(Config, Dep, 3).
-
-use_source(_Config, Dep, 0) ->
-    ?ABORT("Failed to acquire source from ~p after 3 tries.\n",
-           [Dep#dep.source]);
-use_source(Config, Dep, Count) ->
-    case filelib:is_dir(Dep#dep.dir) of
-        true ->
-            %% Already downloaded -- verify the versioning matches the regex
-            case is_app_available(Config, Dep#dep.app, Dep#dep.vsn_regex,
-                                  Dep#dep.dir, Dep#dep.is_raw) of
-                {Config1, {true, _}} ->
-                    Dir = filename:join(Dep#dep.dir, "ebin"),
-                    ok = filelib:ensure_dir(filename:join(Dir, "dummy")),
-                    %% Available version matches up -- we're good to go;
-                    %% add the app dir to our code path
-                    true = code:add_patha(Dir),
-                    {Config1, Dep};
-                {_Config1, {false, Reason}} ->
-                    %% The app that was downloaded doesn't match up (or had
-                    %% errors or something). For the time being, abort.
-                    ?ABORT("Dependency dir ~s failed application validation "
-                           "with reason:~n~p.\n", [Dep#dep.dir, Reason])
-            end;
-        false ->
-            ?CONSOLE("Pulling ~p from ~p\n", [Dep#dep.app, Dep#dep.source]),
-            require_source_engine(Dep#dep.source),
-            {true, TargetDir} = get_deps_dir(Config, Dep#dep.app),
-            download_source(TargetDir, Dep#dep.source),
-            use_source(Config, Dep#dep { dir = TargetDir }, Count-1)
-    end.
-
--record(p4_settings, {
-          client=undefined,
-          transport="tcp4:perforce:1666",
-          username,
-          password
-         }).
-init_p4_settings(Basename) ->
-    #p4_settings{client =
-                     case inet:gethostname() of
-                         {ok,HostName} ->
-                             HostName ++ "-"
-                                 ++ os:getenv("USER") ++ "-"
-                                 ++ Basename
-                                 ++ "-Rebar-automated-download"
-                     end}.
-
-download_source(AppDir, {p4, Url}) ->
-    download_source(AppDir, {p4, Url, "#head"});
-download_source(AppDir, {p4, Url, Rev}) ->
-    download_source(AppDir, {p4, Url, Rev, init_p4_settings(filename:basename(AppDir))});
-download_source(AppDir, {p4, Url, _Rev, Settings}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh_send("p4 client -i",
-                   ?FMT("Client: ~s~n"
-                        ++"Description: generated by Rebar~n"
-                        ++"Root: ~s~n"
-                        ++"View:~n"
-                        ++"  ~s/...  //~s/...~n",
-                        [Settings#p4_settings.client,
-                         AppDir,
-                         Url,
-                         Settings#p4_settings.client]),
-                       []),
-    rebar_utils:sh(?FMT("p4 -c ~s sync -f", [Settings#p4_settings.client]), []);
-download_source(AppDir, {hg, Url, Rev}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("hg clone -U ~s ~s", [Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]),
-    rebar_utils:sh(?FMT("hg update ~s", [Rev]), [{cd, AppDir}]);
-download_source(AppDir, {git, Url}) ->
-    download_source(AppDir, {git, Url, {branch, "HEAD"}});
-download_source(AppDir, {git, Url, ""}) ->
-    download_source(AppDir, {git, Url, {branch, "HEAD"}});
-download_source(AppDir, {git, Url, {branch, Branch}}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("git clone -n ~s ~s", [Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]),
-    rebar_utils:sh(?FMT("git checkout -q origin/~s", [Branch]), [{cd, AppDir}]);
-download_source(AppDir, {git, Url, {tag, Tag}}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("git clone -n ~s ~s", [Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]),
-    rebar_utils:sh(?FMT("git checkout -q ~s", [Tag]), [{cd, AppDir}]);
-download_source(AppDir, {git, Url, Rev}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("git clone -n ~s ~s", [Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]),
-    rebar_utils:sh(?FMT("git checkout -q ~s", [Rev]), [{cd, AppDir}]);
-download_source(AppDir, {bzr, Url, Rev}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("bzr branch -r ~s ~s ~s",
-                        [Rev, Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]);
-download_source(AppDir, {svn, Url, Rev}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("svn checkout -r ~s ~s ~s",
-                        [Rev, Url, filename:basename(AppDir)]),
-                   [{cd, filename:dirname(AppDir)}]);
-download_source(AppDir, {rsync, Url}) ->
-    ok = filelib:ensure_dir(AppDir),
-    rebar_utils:sh(?FMT("rsync -az --delete ~s/ ~s", [Url, AppDir]), []);
-download_source(AppDir, {fossil, Url}) ->
-    download_source(AppDir, {fossil, Url, ""});
-download_source(AppDir, {fossil, Url, Version}) ->
-    Repository = filename:join(AppDir, filename:basename(AppDir) ++ ".fossil"),
-    ok = filelib:ensure_dir(Repository),
-    ok = file:set_cwd(AppDir),
-    rebar_utils:sh(?FMT("fossil clone ~s ~s", [Url, Repository]),
-                   [{cd, AppDir}]),
-    rebar_utils:sh(?FMT("fossil open ~s ~s --nested", [Repository, Version]),
-                   []).
-
-update_source(Config, Dep) ->
-    %% It's possible when updating a source, that a given dep does not have a
-    %% VCS directory, such as when a source archive is built of a project, with
-    %% all deps already downloaded/included. So, verify that the necessary VCS
-    %% directory exists before attempting to do the update.
-    {true, AppDir} = get_deps_dir(Config, Dep#dep.app),
-    case has_vcs_dir(element(1, Dep#dep.source), AppDir) of
-        true ->
-            ?CONSOLE("Updating ~p from ~p\n", [Dep#dep.app, Dep#dep.source]),
-            require_source_engine(Dep#dep.source),
-            update_source1(AppDir, Dep#dep.source),
-            Dep;
-        false ->
-            ?WARN("Skipping update for ~p: "
-                  "no VCS directory available!\n", [Dep]),
-            Dep
-    end.
-
-update_source1(AppDir, Args) when element(1, Args) =:= p4 ->
-    download_source(AppDir, Args);
-update_source1(AppDir, {git, Url}) ->
-    update_source1(AppDir, {git, Url, {branch, "HEAD"}});
-update_source1(AppDir, {git, Url, ""}) ->
-    update_source1(AppDir, {git, Url, {branch, "HEAD"}});
-update_source1(AppDir, {git, _Url, {branch, Branch}}) ->
-    ShOpts = [{cd, AppDir}],
-    rebar_utils:sh("git fetch origin", ShOpts),
-    rebar_utils:sh(?FMT("git checkout -q ~s", [Branch]), ShOpts),
-    rebar_utils:sh(
-      ?FMT("git pull --ff-only --no-rebase -q origin ~s", [Branch]),ShOpts);
-update_source1(AppDir, {git, _Url, {tag, Tag}}) ->
-    ShOpts = [{cd, AppDir}],
-    rebar_utils:sh("git fetch origin", ShOpts),
-    rebar_utils:sh(?FMT("git checkout -q ~s", [Tag]), ShOpts);
-update_source1(AppDir, {git, _Url, Refspec}) ->
-    ShOpts = [{cd, AppDir}],
-    rebar_utils:sh("git fetch origin", ShOpts),
-    rebar_utils:sh(?FMT("git checkout -q ~s", [Refspec]), ShOpts);
-update_source1(AppDir, {svn, _Url, Rev}) ->
-    rebar_utils:sh(?FMT("svn up -r ~s", [Rev]), [{cd, AppDir}]);
-update_source1(AppDir, {hg, _Url, Rev}) ->
-    rebar_utils:sh(?FMT("hg pull -u -r ~s", [Rev]), [{cd, AppDir}]);
-update_source1(AppDir, {bzr, _Url, Rev}) ->
-    rebar_utils:sh(?FMT("bzr update -r ~s", [Rev]), [{cd, AppDir}]);
-update_source1(AppDir, {rsync, Url}) ->
-    rebar_utils:sh(?FMT("rsync -az --delete ~s/ ~s",[Url,AppDir]),[]);
-update_source1(AppDir, {fossil, Url}) ->
-    update_source1(AppDir, {fossil, Url, ""});
-update_source1(AppDir, {fossil, _Url, Version}) ->
-    ok = file:set_cwd(AppDir),
-    rebar_utils:sh("fossil pull", [{cd, AppDir}]),
-    rebar_utils:sh(?FMT("fossil update ~s", [Version]), []).
-
-%% Recursively update deps, this is not done via rebar's usual dep traversal as
-%% that is the wrong order (tips are updated before branches). Instead we do a
-%% traverse the deps at each level completely before traversing *their* deps.
-%% This allows updates to actually propogate down the tree, rather than fail to
-%% flow up the tree, which was the previous behaviour.
-update_deps_int(Config0, UDD) ->
-    %% Determine what deps are required
-    ConfDir = filename:basename(rebar_utils:get_cwd()),
-    RawDeps = rebar_config:get_local(Config0, deps, []),
-    {Config1, Deps} = find_deps(Config0, read, RawDeps),
-
-    %% Update each dep
-    UpdatedDeps = [update_source(Config1, D)
-                   || D <- Deps, D#dep.source =/= undefined,
-                      not lists:member(D, UDD),
-                      not should_skip_update_dep(Config1, D)
-                  ],
-
-    lists:foldl(fun(Dep, {Config, Updated}) ->
-                        {true, AppDir} = get_deps_dir(Config, Dep#dep.app),
-                        Config2 = case has_vcs_dir(element(1, Dep#dep.source),
-                                                   AppDir) of
-                                      false ->
-                                          %% If the dep did not exist (maybe it
-                                          %% was added), clone it.
-                                          %% We'll traverse ITS deps below and
-                                          %% clone them if needed.
-                                          {C1, _D1} = use_source(Config, Dep),
-                                          C1;
-                                      true ->
-                                          Config
-                                  end,
-                        ok = file:set_cwd(AppDir),
-                        Config3 = rebar_config:new(Config2),
-                        %% track where a dep comes from...
-                        DepOwner = dict:append(
-                                     Dep, ConfDir,
-                                     rebar_config:get_xconf(Config3, depowner,
-                                                            dict:new())),
-                        Config4 = rebar_config:set_xconf(Config3, depowner,
-                                                         DepOwner),
-
-                        {Config5, Res} = update_deps_int(Config4, Updated),
-                        {Config5, lists:umerge(lists:sort(Res),
-                                               lists:sort(Updated))}
-                end, {Config1, lists:umerge(lists:sort(UpdatedDeps),
-                                            lists:sort(UDD))}, UpdatedDeps).
-
-should_skip_update_dep(Config, Dep) ->
-    {true, AppDir} = get_deps_dir(Config, Dep#dep.app),
-    case rebar_app_utils:is_app_dir(AppDir) of
-        false ->
-            false;
-        {true, AppFile} ->
-            case rebar_app_utils:is_skipped_app(Config, AppFile) of
-                {_Config, {true, _SkippedApp}} ->
-                    true;
-                _ ->
-                    false
-            end
-    end.
-
-%% Recursively walk the deps and build a list of them.
-collect_deps(Dir, C) ->
-    case file:set_cwd(Dir) of
-        ok ->
-            Config = rebar_config:new(C),
-            RawDeps = rebar_config:get_local(Config, deps, []),
-            {Config1, Deps} = find_deps(Config, read, RawDeps),
-
-            lists:flatten(Deps ++ [begin
-                                       {true, AppDir} = get_deps_dir(
-                                                          Config1, Dep#dep.app),
-                                       collect_deps(AppDir, C)
-                                   end || Dep <- Deps]);
-        _ ->
-            []
-    end.
-
-
-%% ===================================================================
-%% Source helper functions
-%% ===================================================================
-
-source_engine_avail(Source) ->
-    Name = element(1, Source),
-    source_engine_avail(Name, Source).
-
-source_engine_avail(Name, Source)
-  when Name == hg; Name == git; Name == svn; Name == bzr; Name == rsync;
-       Name == fossil; Name == p4 ->
-    case vcs_client_vsn(Name) >= required_vcs_client_vsn(Name) of
-        true ->
-            true;
-        false ->
-            ?ABORT("Rebar requires version ~p or higher of ~s to process ~p\n",
-                   [required_vcs_client_vsn(Name), Name, Source])
-    end.
-
-vcs_client_vsn(false, _VsnArg, _VsnRegex) ->
-    false;
-vcs_client_vsn(Path, VsnArg, VsnRegex) ->
-    {ok, Info} = rebar_utils:sh(Path ++ VsnArg, [{env, [{"LANG", "C"}]},
-                                                 {use_stdout, false}]),
-    case re:run(Info, VsnRegex, [{capture, all_but_first, list}]) of
-        {match, Match} ->
-            list_to_tuple([list_to_integer(S) || S <- Match]);
-        _ ->
-            false
-    end.
-
-required_vcs_client_vsn(p4)     -> {2013, 1};
-required_vcs_client_vsn(hg)     -> {1, 1};
-required_vcs_client_vsn(git)    -> {1, 5};
-required_vcs_client_vsn(bzr)    -> {2, 0};
-required_vcs_client_vsn(svn)    -> {1, 6};
-required_vcs_client_vsn(rsync)  -> {2, 0};
-required_vcs_client_vsn(fossil) -> {1, 0}.
-
-vcs_client_vsn(p4) ->
-    vcs_client_vsn(rebar_utils:find_executable("p4"), " -V",
-                   "Rev\\. .*/(\\d+)\\.(\\d)/");
-vcs_client_vsn(hg) ->
-    vcs_client_vsn(rebar_utils:find_executable("hg"), " --version",
-                   "version (\\d+).(\\d+)");
-vcs_client_vsn(git) ->
-    vcs_client_vsn(rebar_utils:find_executable("git"), " --version",
-                   "git version (\\d+).(\\d+)");
-vcs_client_vsn(bzr) ->
-    vcs_client_vsn(rebar_utils:find_executable("bzr"), " --version",
-                   "Bazaar \\(bzr\\) (\\d+).(\\d+)");
-vcs_client_vsn(svn) ->
-    vcs_client_vsn(rebar_utils:find_executable("svn"), " --version",
-                   "svn, version (\\d+).(\\d+)");
-vcs_client_vsn(rsync) ->
-    vcs_client_vsn(rebar_utils:find_executable("rsync"), " --version",
-                   "rsync  version (\\d+).(\\d+)");
-vcs_client_vsn(fossil) ->
-    vcs_client_vsn(rebar_utils:find_executable("fossil"), " version",
-                   "version (\\d+).(\\d+)").
-
-has_vcs_dir(p4, _) ->
-    true;
-has_vcs_dir(git, Dir) ->
-    filelib:is_dir(filename:join(Dir, ".git"));
-has_vcs_dir(hg, Dir) ->
-    filelib:is_dir(filename:join(Dir, ".hg"));
-has_vcs_dir(bzr, Dir) ->
-    filelib:is_dir(filename:join(Dir, ".bzr"));
-has_vcs_dir(svn, Dir) ->
-    filelib:is_dir(filename:join(Dir, ".svn"))
-        orelse filelib:is_dir(filename:join(Dir, "_svn"));
-has_vcs_dir(rsync, _) ->
-    true;
-has_vcs_dir(_, _) ->
-    true.
-
-print_source(#dep{app=App, source=Source}) ->
-    ?CONSOLE("~s~n", [format_source(App, Source)]).
-
-format_source(App, {p4, Url}) ->
-    format_source(App, {p4, Url, "#head"});
-format_source(App, {git, Url}) ->
-    ?FMT("~p BRANCH ~s ~s", [App, "HEAD", Url]);
-format_source(App, {git, Url, ""}) ->
-    ?FMT("~p BRANCH ~s ~s", [App, "HEAD", Url]);
-format_source(App, {git, Url, {branch, Branch}}) ->
-    ?FMT("~p BRANCH ~s ~s", [App, Branch, Url]);
-format_source(App, {git, Url, {tag, Tag}}) ->
-    ?FMT("~p TAG ~s ~s", [App, Tag, Url]);
-format_source(App, {_, Url, Rev}) ->
-    ?FMT("~p REV ~s ~s", [App, Rev, Url]);
-format_source(App, undefined) ->
-    ?FMT("~p", [App]).