Merge branch 'master' into app-discover-profile-duplication

Conflicts:
	test/rebar_profiles_SUITE.erl

29 files changed, 465 insertions, 208 deletions

diff --git a/src/rebar.app.src b/src/rebar.app.src
index 63cca9c..b404c42 100644
--- a/src/rebar.app.src
+++ b/src/rebar.app.src
@@ -49,6 +49,7 @@
                      rebar_prv_report,
                      rebar_prv_shell,
                      rebar_prv_tar,
+                     rebar_prv_unlock,
                      rebar_prv_update,
                      rebar_prv_upgrade,
                      rebar_prv_version,
diff --git a/src/rebar3.erl b/src/rebar3.erl
index 460bc36..b0cc949 100644
--- a/src/rebar3.erl
+++ b/src/rebar3.erl
@@ -27,6 +27,7 @@
 -module(rebar3).
 
 -export([main/1,
+         run/1,
          run/2,
          global_option_spec_list/0,
          init_config/0,
@@ -114,6 +115,8 @@ run_aux(State, RawArgs) ->
     State2 = case os:getenv("REBAR_PROFILE") of
                  false ->
                      State;
+                 "" ->
+                     State;
                  Profile ->
                      rebar_state:apply_profiles(State, [list_to_atom(Profile)])
              end,
@@ -134,7 +137,9 @@ run_aux(State, RawArgs) ->
 
     {Task, Args} = parse_args(RawArgs),
 
-    rebar_core:init_command(rebar_state:command_args(State7, Args), Task).
+    State8 = rebar_state:code_paths(State7, default, code:get_path()),
+
+    rebar_core:init_command(rebar_state:command_args(State8, Args), Task).
 
 init_config() ->
     %% Initialize logging system
diff --git a/src/rebar_api.erl b/src/rebar_api.erl
index 3fc7f61..88c7538 100644
--- a/src/rebar_api.erl
+++ b/src/rebar_api.erl
@@ -8,7 +8,9 @@
          debug/2, info/2, warn/2, error/2,
          expand_env_variable/3,
          get_arch/0,
-         wordsize/0]).
+         wordsize/0,
+         add_deps_to_path/1,
+         restore_code_path/1]).
 
 -export_type([rebar_dict/0, rebar_digraph/0]).
 
@@ -48,3 +50,12 @@ get_arch() ->
 
 wordsize() ->
     rebar_utils:wordsize().
+
+
+%% Add deps to the code path
+add_deps_to_path(State) ->
+  code:add_pathsa(rebar_state:code_paths(State, all_deps)).
+
+%% Revert to only having the beams necessary for running rebar3 and plugins in the path
+restore_code_path(State) ->
+  rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)).
diff --git a/src/rebar_app_discover.erl b/src/rebar_app_discover.erl
index 16dcf24..41f41f5 100644
--- a/src/rebar_app_discover.erl
+++ b/src/rebar_app_discover.erl
@@ -37,12 +37,13 @@ merge_deps(AppInfo, State) ->
     Default = rebar_state:default(State),
     CurrentProfiles = rebar_state:current_profiles(State),
     Name = rebar_app_info:name(AppInfo),
-    C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
+    C = project_app_config(AppInfo, State),
 
     %% We reset the opts here to default so no profiles are applied multiple times
     AppState = rebar_state:apply_overrides(
                  rebar_state:apply_profiles(
-                   rebar_state:new(rebar_state:opts(State, Default), C, rebar_app_info:dir(AppInfo)), CurrentProfiles), Name),
+                   rebar_state:new(reset_hooks(rebar_state:opts(State, Default)), C,
+                                  rebar_app_info:dir(AppInfo)), CurrentProfiles), Name),
     AppInfo1 = rebar_app_info:state(AppInfo, AppState),
 
     State1 = lists:foldl(fun(Profile, StateAcc) ->
@@ -56,6 +57,27 @@ merge_deps(AppInfo, State) ->
 
     {AppInfo1, State1}.
 
+project_app_config(AppInfo, State) ->
+    C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
+    Dir = rebar_app_info:dir(AppInfo),
+    maybe_reset_hooks(C, Dir, State).
+
+%% Here we check if the app is at the root of the project.
+%% If it is, then drop the hooks from the config so they aren't run twice
+maybe_reset_hooks(C, Dir, State) ->
+    case filename:dirname(rebar_dir:root_dir(State)) of
+        Dir ->
+            C1 = proplists:delete(provider_hooks, C),
+            proplists:delete(hooks, C1);
+        _ ->
+            C
+    end.
+
+reset_hooks(State) ->
+    lists:foldl(fun(Key, StateAcc) ->
+                        rebar_state:set(StateAcc, Key, [])
+                end, State, [post_hooks, pre_hooks, provider_hooks]).
+
 -spec all_app_dirs(list(file:name())) -> list(file:name()).
 all_app_dirs(LibDirs) ->
     lists:flatmap(fun(LibDir) ->
diff --git a/src/rebar_app_info.erl b/src/rebar_app_info.erl
index 9659c0b..91640f2 100644
--- a/src/rebar_app_info.erl
+++ b/src/rebar_app_info.erl
@@ -61,7 +61,7 @@
 %%============================================================================
 %% types
 %%============================================================================
--type t() :: record(app_info_t).
+-type t() :: #app_info_t{}.
 
 %%============================================================================
 %% API
@@ -157,6 +157,19 @@ app_file(AppInfo=#app_info_t{}, AppFile) ->
     AppInfo#app_info_t{app_file=AppFile}.
 
 -spec app_details(t()) -> list().
+app_details(AppInfo=#app_info_t{app_details=[]}) ->
+    AppFile = case app_file(AppInfo) of
+                  undefined ->
+                      app_file_src(AppInfo);
+                  File ->
+                      File
+              end,
+    case file:consult(AppFile) of
+        {ok, [{application, _, AppDetails}]} ->
+            AppDetails;
+        _ ->
+            []
+    end;
 app_details(#app_info_t{app_details=AppDetails}) ->
     AppDetails.
 
diff --git a/src/rebar_base_compiler.erl b/src/rebar_base_compiler.erl
index df950d7..0101218 100644
--- a/src/rebar_base_compiler.erl
+++ b/src/rebar_base_compiler.erl
@@ -114,7 +114,7 @@ compile_each([Source | Rest], Config, CompileFn) ->
         skipped ->
             ?DEBUG("~sSkipped ~s", [rebar_utils:indent(1), filename:basename(Source)]);
         Error ->
-            ?INFO("Compiling ~s failed:",
+            ?ERROR("Compiling ~s failed",
                      [maybe_absname(Config, Source)]),
             maybe_report(Error),
             ?DEBUG("Compilation failed: ~p", [Error]),
diff --git a/src/rebar_config.erl b/src/rebar_config.erl
index 76e03ea..c858fef 100644
--- a/src/rebar_config.erl
+++ b/src/rebar_config.erl
@@ -57,7 +57,6 @@ consult_file(File) ->
                     {ok, Terms} = consult_and_eval(File, Script),
                     Terms;
                 false ->
-                    ?DEBUG("Consult config file ~p", [File]),
                     try_consult(File)
             end
     end.
@@ -70,7 +69,7 @@ merge_locks(Config, [[]]) ->
     Config;
 %% lockfile with entries
 merge_locks(Config, [Locks]) ->
-    {deps, ConfigDeps} = lists:keyfind(deps, 1, Config),
+    ConfigDeps = proplists:get_value(deps, Config, []),
     %% We want the top level deps only from the lock file.
     %% This ensures deterministic overrides for configs.
     %% Then check if any new deps have been added to the config
diff --git a/src/rebar_dir.erl b/src/rebar_dir.erl
index 1885e9a..a94c72d 100644
--- a/src/rebar_dir.erl
+++ b/src/rebar_dir.erl
@@ -1,8 +1,10 @@
 -module(rebar_dir).
 
 -export([base_dir/1,
+         profile_dir/2,
          deps_dir/1,
          deps_dir/2,
+         root_dir/1,
          checkouts_dir/1,
          checkouts_dir/2,
          plugins_dir/1,
@@ -24,7 +26,10 @@
 
 -spec base_dir(rebar_state:t()) -> file:filename_all().
 base_dir(State) ->
-    Profiles = rebar_state:current_profiles(State),
+    profile_dir(State, rebar_state:current_profiles(State)).
+
+-spec profile_dir(rebar_state:t(), [atom()]) -> file:filename_all().
+profile_dir(State, Profiles) ->
     ProfilesStrings = case [ec_cnv:to_list(P) || P <- Profiles] of
         ["default"]      -> ["default"];
         %% drop `default` from the profile dir if it's implicit and reverse order
@@ -34,6 +39,7 @@ base_dir(State) ->
     ProfilesDir = string:join(ProfilesStrings, "+"),
     filename:join(rebar_state:get(State, base_dir, ?DEFAULT_BASE_DIR), ProfilesDir).
 
+
 -spec deps_dir(rebar_state:t()) -> file:filename_all().
 deps_dir(State) ->
     filename:join(base_dir(State), rebar_state:get(State, deps_dir, ?DEFAULT_DEPS_DIR)).
@@ -43,7 +49,7 @@ deps_dir(DepsDir, App) ->
     filename:join(DepsDir, App).
 
 root_dir(State) ->
-    rebar_state:get(State, root_dir, ?DEFAULT_ROOT_DIR).
+    filename:absname(rebar_state:get(State, root_dir, ?DEFAULT_ROOT_DIR)).
 
 -spec checkouts_dir(rebar_state:t()) -> file:filename_all().
 checkouts_dir(State) ->
diff --git a/src/rebar_erlc_compiler.erl b/src/rebar_erlc_compiler.erl
index f245eb5..862d21e 100644
--- a/src/rebar_erlc_compiler.erl
+++ b/src/rebar_erlc_compiler.erl
@@ -148,8 +148,8 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
 
     %% Make sure that ebin/ exists and is on the path
     ok = filelib:ensure_dir(filename:join(OutDir, "dummy.beam")),
-    CurrPath = code:get_path(),
-    true = code:add_path(filename:absname(OutDir)),
+    true = code:add_patha(filename:absname(OutDir)),
+
     OutDir1 = proplists:get_value(outdir, ErlOpts, OutDir),
 
     G = init_erlcinfo(proplists:get_all_values(i, ErlOpts), AllErlFiles, Dir),
@@ -161,7 +161,7 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
                                                 filename:extension(File) =:= ".erl"],
 
     NeededErlFiles = needed_files(G, ErlOpts, Dir, OutDir1, AllErlFiles),
-    ErlFirstFiles = erl_first_files(Config, NeededErlFiles),
+    ErlFirstFiles = erl_first_files(Config, Dir, NeededErlFiles),
     {DepErls, OtherErls} = lists:partition(
                              fun(Source) -> digraph:in_degree(G, Source) > 0 end,
                              [File || File <- NeededErlFiles, not lists:member(File, ErlFirstFiles)]),
@@ -173,13 +173,13 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
       fun(S, C) ->
               internal_erl_compile(C, Dir, S, OutDir1, ErlOpts)
       end),
-    true = code:set_path(CurrPath),
     ok.
 
-erl_first_files(Config, NeededErlFiles) ->
+erl_first_files(Config, Dir, NeededErlFiles) ->
     ErlFirstFilesConf = rebar_state:get(Config, erl_first_files, []),
     %% NOTE: order of files in ErlFirstFiles is important!
-    [File || File <- ErlFirstFilesConf, lists:member(File, NeededErlFiles)].
+    [filename:join(Dir, File) || File <- ErlFirstFilesConf,
+                                 lists:member(filename:join(Dir, File), NeededErlFiles)].
 
 %% Get subset of SourceFiles which need to be recompiled, respecting
 %% dependencies induced by given graph G.
@@ -541,9 +541,6 @@ maybe_expand_include_lib_path(File, Dir) ->
 %% The use of -include_lib was probably incorrect by the user but lets try to make it work.
 %% We search in the outdir and outdir/../include to see if the header exists.
 warn_and_find_path(File, Dir) ->
-    ?WARN("Bad use of -include_lib(\"~s\")."
-         " First path component should be the name of an application."
-         " You probably meant -include(\"~s\").", [File, File]),
     SrcHeader = filename:join(Dir, File),
     case filelib:is_regular(SrcHeader) of
         true ->
@@ -555,7 +552,6 @@ warn_and_find_path(File, Dir) ->
                 true ->
                     [filename:join(IncludeDir, File)];
                 false ->
-                    ?WARN("Could not find header for -include_lib(\"~s\").", [File]),
                     []
             end
     end.
diff --git a/src/rebar_otp_app.erl b/src/rebar_otp_app.erl
index a93defc..260343d 100644
--- a/src/rebar_otp_app.erl
+++ b/src/rebar_otp_app.erl
@@ -120,10 +120,6 @@ preprocess(State, AppInfo, AppSrcFile) ->
             AppFile = rebar_app_utils:app_src_to_app(OutDir, AppSrcFile),
             ok = rebar_file_utils:write_file_if_contents_differ(AppFile, Spec),
 
-            %% Make certain that the ebin/ directory is available
-            %% on the code path
-            true = code:add_path(filename:absname(filename:dirname(AppFile))),
-
             AppFile;
         {error, Reason} ->
             ?PRV_ERROR({file_read, AppSrcFile, Reason})
@@ -132,7 +128,6 @@ preprocess(State, AppInfo, AppSrcFile) ->
 load_app_vars(State) ->
     case rebar_state:get(State, app_vars_file, undefined) of
         undefined ->
-            ?DEBUG("No app_vars_file defined.", []),
             [];
         Filename ->
             ?INFO("Loading app vars from ~p", [Filename]),
diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl
index 1d5806b..9038759 100644
--- a/src/rebar_prv_common_test.erl
+++ b/src/rebar_prv_common_test.erl
@@ -38,6 +38,8 @@ init(State) ->
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
     ?INFO("Running Common Test suites...", []),
+    code:add_pathsa(rebar_state:code_paths(State, all_deps)),
+
     %% Run ct provider prehooks
     Providers = rebar_state:providers(State),
     Cwd = rebar_dir:get_cwd(),
@@ -47,11 +49,14 @@ do(State) ->
         {ok, State1} = Result ->
             %% Run ct provider posthooks
             rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State1),
+            rebar_utils:cleanup_code_path(rebar_state:code_paths(State1, default)),
             Result;
         ?PRV_ERROR(_) = Error ->
+            rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
             Error
     catch
         throw:{error, Reason} ->
+            rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
             ?PRV_ERROR(Reason)
     end.
 
diff --git a/src/rebar_prv_compile.erl b/src/rebar_prv_compile.erl
index 94a1e0b..1fb29bd 100644
--- a/src/rebar_prv_compile.erl
+++ b/src/rebar_prv_compile.erl
@@ -31,27 +31,33 @@ init(State) ->
 
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
+    DepsPaths = rebar_state:code_paths(State, all_deps),
+    code:add_pathsa(DepsPaths),
+
     ProjectApps = rebar_state:project_apps(State),
     Providers = rebar_state:providers(State),
     Deps = rebar_state:deps_to_build(State),
     Cwd = rebar_dir:get_cwd(),
 
-    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, State),
-
     %% Need to allow global config vars used on deps
     %% Right now no way to differeniate and just give deps a new state
     EmptyState = rebar_state:new(),
     build_apps(EmptyState, Providers, Deps),
 
-    %% Use the project State for building project apps
-    %% Set hooks to empty so top-level hooks aren't run for each project app
-    State2 = rebar_state:set(rebar_state:set(State, post_hooks, []), pre_hooks, []),
     {ok, ProjectApps1} = rebar_digraph:compile_order(ProjectApps),
 
-    ProjectApps2 = build_apps(State2, Providers, ProjectApps1),
-    State3 = rebar_state:project_apps(State2, ProjectApps2),
+    %% Run top level hooks *before* project apps compiled but *after* deps are
+    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, State),
+
+    ProjectApps2 = build_apps(State, Providers, ProjectApps1),
+    State2 = rebar_state:project_apps(State, ProjectApps2),
+
+    ProjAppsPaths = [filename:join(rebar_app_info:out_dir(X), "ebin") || X <- ProjectApps2],
+    State3 = rebar_state:code_paths(State2, all_deps, DepsPaths ++ ProjAppsPaths),
 
-    rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State3),
+    rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State2),
+
+    rebar_utils:cleanup_code_path(rebar_state:code_paths(State3, default)),
 
     {ok, State3}.
 
@@ -77,12 +83,10 @@ build_app(State, Providers, AppInfo) ->
         end,
 
     %% Legacy hook support
-
     rebar_hooks:run_all_hooks(AppDir, pre, ?PROVIDER,  Providers, S),
     AppInfo1 = compile(S, AppInfo),
     rebar_hooks:run_all_hooks(AppDir, post, ?PROVIDER, Providers, S),
 
-    true = code:add_patha(rebar_app_info:ebin_dir(AppInfo1)),
     AppInfo1.
 
 compile(State, AppInfo) ->
diff --git a/src/rebar_prv_cover.erl b/src/rebar_prv_cover.erl
index 83fe012..b38c6b0 100644
--- a/src/rebar_prv_cover.erl
+++ b/src/rebar_prv_cover.erl
@@ -150,7 +150,7 @@ analysis(State, Task) ->
                   {Mod, process(Answer), File}
               end,
               Mods),
-    true = code:set_path(OldPath),
+    true = rebar_utils:cleanup_code_path(OldPath),
     Analysis.
 
 restore_cover_paths(State) ->
diff --git a/src/rebar_prv_dialyzer.erl b/src/rebar_prv_dialyzer.erl
index ef6a64c..67cf4b9 100644
--- a/src/rebar_prv_dialyzer.erl
+++ b/src/rebar_prv_dialyzer.erl
@@ -64,6 +64,7 @@ short_desc() ->
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
     ?INFO("Dialyzer starting, this may take a while...", []),
+    code:add_pathsa(rebar_state:code_paths(State, all_deps)),
     Plt = get_plt_location(State),
     Apps = rebar_state:project_apps(State),
 
@@ -74,6 +75,8 @@ do(State) ->
             ?PRV_ERROR({error_processing_apps, Error});
         throw:{dialyzer_warnings, Warnings} ->
             ?PRV_ERROR({dialyzer_warnings, Warnings})
+    after
+        rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default))
     end.
 
 -spec format_error(any()) -> iolist().
diff --git a/src/rebar_prv_erlydtl_compiler.erl b/src/rebar_prv_erlydtl_compiler.erl
index c5fb77a..a7442af 100644
--- a/src/rebar_prv_erlydtl_compiler.erl
+++ b/src/rebar_prv_erlydtl_compiler.erl
@@ -125,39 +125,48 @@ init(State) ->
 
 do(State) ->
     ?INFO("Running erlydtl...", []),
-    DtlOpts = proplists:unfold(rebar_state:get(State, erlydtl_opts, [])),
-
-    %% We need a project app to store the results under in _build
-    %% If there is more than 1 project app, check for an app config
-    %% if that doesn't exist, error out.
-    case rebar_state:project_apps(State) of
-        [App] ->
-            run_erlydtl(App, DtlOpts, State),
-            {ok, State};
-        Apps ->
-            case option(app, DtlOpts) of
-                undefined ->
-                    ?PRV_ERROR(no_main_app);
-                Name ->
-                    run_erlydtl(rebar_app_utils:find(Name, Apps), DtlOpts, State),
-                    {ok, State}
-            end
+    case rebar_state:get(State, escript_main_app, undefined) of
+        undefined ->
+            Dir = rebar_state:dir(State),
+            case rebar_app_discover:find_app(Dir, all) of
+                {true, AppInfo} ->
+                    AllApps = rebar_state:project_apps(State) ++ rebar_state:all_deps(State),
+                    case rebar_app_utils:find(rebar_app_info:name(AppInfo), AllApps) of
+                        {ok, AppInfo1} ->
+                            %% Use the existing app info instead of newly created one
+                            run_erlydtl(AppInfo1, State);
+                        _ ->
+                            run_erlydtl(AppInfo, State)
+                    end,
+                    {ok, State};
+                _ ->
+                    ?PRV_ERROR(no_main_app)
+            end;
+        Name ->
+            AllApps = rebar_state:project_apps(State) ++ rebar_state:all_deps(State),
+            {ok, App} = rebar_app_utils:find(Name, AllApps),
+            run_erlydtl(App, State),
+            {ok, State}
     end.
 
-run_erlydtl(App, DtlOpts, State) ->
-    Dir = rebar_app_info:dir(App),
+run_erlydtl(App, State) ->
+    Dir = rebar_state:dir(State),
+    DtlOpts = proplists:unfold(rebar_state:get(State, erlydtl_opts, [])),
+    TemplateDir = filename:join(Dir, option(doc_root, DtlOpts)),
+    DtlOpts2 = [{doc_root, TemplateDir} | proplists:delete(doc_root, DtlOpts)],
     OutDir = rebar_app_info:ebin_dir(App),
+    filelib:ensure_dir(filename:join(OutDir, "dummy.beam")),
     rebar_base_compiler:run(State,
                             [],
-                            filename:join(Dir, option(doc_root, DtlOpts)),
-                            option(source_ext, DtlOpts),
+                            TemplateDir,
+                            option(source_ext, DtlOpts2),
                             OutDir,
-                            option(module_ext, DtlOpts) ++ ".beam",
+                            option(module_ext, DtlOpts2) ++ ".beam",
                             fun(S, T, C) ->
-                                    compile_dtl(C, S, T, DtlOpts, Dir, OutDir)
+                                    compile_dtl(C, S, T, DtlOpts2, Dir, OutDir)
                             end,
                             [{check_last_mod, false},
-                             {recursive, option(recursive, DtlOpts)}]).
+                             {recursive, option(recursive, DtlOpts2)}]).
 
 -spec format_error(any()) ->  iolist().
 format_error(no_main_app) ->
diff --git a/src/rebar_prv_escriptize.erl b/src/rebar_prv_escriptize.erl
index 12ceaca..03332a0 100644
--- a/src/rebar_prv_escriptize.erl
+++ b/src/rebar_prv_escriptize.erl
@@ -62,17 +62,18 @@ desc() ->
 
 do(State) ->
     ?INFO("Building escript...", []),
-    case rebar_state:project_apps(State) of
-        [App] ->
-            escriptize(State, App);
-        Apps ->
-            case rebar_state:get(State, escript_main_app, undefined) of
-                undefined ->
-                    ?PRV_ERROR(no_main_app);
-                Name ->
-                    AppInfo = rebar_app_utils:find(Name, Apps),
-                    escriptize(State, AppInfo)
-            end
+    case rebar_state:get(State, escript_main_app, undefined) of
+        undefined ->
+            case rebar_state:project_apps(State) of
+                [App] ->
+                    escriptize(State, App);
+                _ ->
+                    ?PRV_ERROR(no_main_app)
+            end;
+        Name ->
+            AllApps = rebar_state:all_deps(State)++rebar_state:project_apps(State),
+            AppInfo = rebar_app_utils:find(Name, AllApps),
+            escriptize(State, AppInfo)
     end.
 
 escriptize(State0, App) ->
@@ -89,8 +90,9 @@ escriptize(State0, App) ->
     %% in the output file. We then use the .app files for each of these
     %% to pull in all the .beam files.
     InclApps = lists:usort(rebar_state:get(State, escript_incl_apps, [])
-                           ++ all_deps(State)),
-    InclBeams = get_app_beams(InclApps),
+                          ++ all_deps(State)),
+    AllApps = rebar_state:all_deps(State)++rebar_state:project_apps(State),
+    InclBeams = get_apps_beams(InclApps, AllApps),
 
     %% Look for a list of extra files to include in the output file.
     %% For internal rebar-private use only. Do not use outside rebar.
@@ -139,22 +141,32 @@ format_error(no_main_app) ->
 %% Internal functions
 %% ===================================================================
 
-get_app_beams(Apps) ->
-    get_app_beams(Apps, []).
+get_apps_beams(Apps, AllApps) ->
+    get_apps_beams(Apps, AllApps, []).
 
-get_app_beams([], Acc) ->
+get_apps_beams([], _, Acc) ->
     Acc;
-get_app_beams([App | Rest], Acc) ->
-    case code:lib_dir(App, ebin) of
-        {error, bad_name} ->
-            throw(?PRV_ERROR({bad_name, App}));
-        Path ->
-            Prefix = filename:join(atom_to_list(App), "ebin"),
-            Acc2 = load_files(Prefix, "*.beam", Path),
-            Acc3 = load_files(Prefix, "*.app", Path),
-            get_app_beams(Rest, Acc3 ++ Acc2 ++ Acc)
+get_apps_beams([App | Rest], AllApps, Acc) ->
+    case rebar_app_utils:find(ec_cnv:to_binary(App), AllApps) of
+        {ok, App1} ->
+            OutDir = filename:absname(rebar_app_info:ebin_dir(App1)),
+            Beams = get_app_beams(App, OutDir),
+            get_apps_beams(Rest, AllApps, Beams ++ Acc);
+        _->
+            case code:lib_dir(App, ebin) of
+                {error, bad_name} ->
+                    throw(?PRV_ERROR({bad_name, App}));
+                Path ->
+                    Beams = get_app_beams(App, Path),
+                    get_apps_beams(Rest, AllApps, Beams ++ Acc)
+            end
     end.
 
+get_app_beams(App, Path) ->
+    Prefix = filename:join(atom_to_list(App), "ebin"),
+    load_files(Prefix, "*.beam", Path) ++
+        load_files(Prefix, "*.app", Path).
+
 get_extra(State) ->
     Extra = rebar_state:get(State, escript_incl_extra, []),
     lists:foldl(fun({Wildcard, Dir}, Files) ->
diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl
index 0ea3ae8..12dd5f9 100644
--- a/src/rebar_prv_eunit.erl
+++ b/src/rebar_prv_eunit.erl
@@ -37,6 +37,7 @@ init(State) ->
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
     ?INFO("Performing EUnit tests...", []),
+    code:add_pathsa(rebar_state:code_paths(State, all_deps)),
     %% Run eunit provider prehooks
     Providers = rebar_state:providers(State),
     Cwd = rebar_dir:get_cwd(),
@@ -48,11 +49,14 @@ do(State) ->
                 {ok, State1} ->
                     %% Run eunit provider posthooks
                     rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State1),
+                    rebar_utils:cleanup_code_path(rebar_state:code_paths(State1, default)),
                     {ok, State1};
                 Error ->
+                    rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
                     Error
             end;
         Error ->
+            rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
             Error
     end.
 
diff --git a/src/rebar_prv_install_deps.erl b/src/rebar_prv_install_deps.erl
index c535b4d..17346f4 100644
--- a/src/rebar_prv_install_deps.erl
+++ b/src/rebar_prv_install_deps.erl
@@ -82,13 +82,9 @@ do(State) ->
                 ?PRV_ERROR({cycles, Cycles});
             {error, Error} ->
                 {error, Error};
-            no_cycle ->
-                case compile_order(Source, ProjectApps) of
-                    {ok, ToCompile} ->
-                        {ok, rebar_state:deps_to_build(State1, ToCompile)};
-                    {error, Error} ->
-                        {error, Error}
-                end
+            {no_cycle, Sorted} ->
+                ToCompile = cull_compile(Sorted, ProjectApps),
+                {ok, rebar_state:deps_to_build(State1, ToCompile)}
         end
     catch
         %% maybe_fetch will maybe_throw an exception to break out of some loops
@@ -132,30 +128,39 @@ handle_deps(Profile, State, Deps, Locks) when is_list(Locks) ->
 handle_deps(_Profile, State, [], _, _) ->
     {ok, [], State};
 handle_deps(Profile, State0, Deps, Upgrade, Locks) ->
-    %% Read in package index and dep graph
-    {Packages, Graph} = rebar_state:packages(State0),
-    Registry = rebar_packages:registry(State0),
-    State = rebar_state:packages(rebar_state:registry(State0, Registry), {Packages, Graph}),
     %% Split source deps from pkg deps, needed to keep backwards compatibility
-    DepsDir = rebar_dir:deps_dir(State),
-    {SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps, State, Locks, 0),
+    DepsDir = profile_dep_dir(State0, Profile),
+
+    {SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps, State0, Locks, 0),
 
     %% Fetch transitive src deps
-    {State1, SrcApps, PkgDeps1, Seen} =
-        update_src_deps(Profile, 0, SrcDeps, PkgDeps, [], State, Upgrade, sets:new(), Locks),
+    {State1, SrcApps, PkgDeps1, Seen} = update_src_deps(Profile, 0, SrcDeps, PkgDeps, []
+                                                       ,State0, Upgrade, sets:new(), Locks),
 
-    {Solved, State2} =
-        update_pkg_deps(Profile, Packages, PkgDeps1, Graph, Upgrade, Seen, State1),
+    {Solved, State4} =
+        case PkgDeps1 of
+            [] ->
+                {[], State1};
+            _ ->
+                %% Read in package index and dep graph
+                {Packages, Graph} = rebar_state:packages(State1),
+                Registry = rebar_packages:registry(State1),
+                State2 = rebar_state:packages(rebar_state:registry(State1, Registry)
+                                            ,{Packages, Graph}),
+
+                update_pkg_deps(Profile, Packages, PkgDeps1
+                               ,Graph, Upgrade, Seen, State2)
+        end,
 
     AllDeps = lists:ukeymerge(2
                              ,lists:ukeysort(2, SrcApps)
                              ,lists:ukeysort(2, Solved)),
-    %% Sort all apps to build order
-    State3 = rebar_state:all_deps(State2, AllDeps),
+
+    State5 = rebar_state:update_all_deps(State4, AllDeps),
     CodePaths = [rebar_app_info:ebin_dir(A) || A <- AllDeps],
-    ok = code:add_pathsa(CodePaths),
+    State6 = rebar_state:update_code_paths(State5, all_deps, CodePaths),
 
-    {ok, AllDeps, State3}.
+    {ok, AllDeps, State6}.
 
 %% ===================================================================
 %% Internal functions
@@ -171,17 +176,11 @@ find_cycles(Apps) ->
     case rebar_digraph:compile_order(Apps) of
         {error, {cycles, Cycles}} -> {cycles, Cycles};
         {error, Error} -> {error, Error};
-        {ok, _} -> no_cycle
+        {ok, Sorted} -> {no_cycle, Sorted}
     end.
 
-compile_order(Source, ProjectApps) ->
-    case rebar_digraph:compile_order(Source) of
-        {ok, Sort} ->
-            %% Valid apps are compiled and good
-            {ok, lists:dropwhile(fun not_needs_compile/1, Sort -- ProjectApps)};
-        {error, Error} ->
-            {error, Error}
-    end.
+cull_compile(TopSortedDeps, ProjectApps) ->
+    lists:dropwhile(fun not_needs_compile/1, TopSortedDeps -- ProjectApps).
 
 update_pkg_deps(Profile, Packages, PkgDeps, Graph, Upgrade, Seen, State) ->
     case PkgDeps of
@@ -203,7 +202,7 @@ update_pkg_deps(Profile, Packages, PkgDeps, Graph, Upgrade, Seen, State) ->
 
 update_pkg_deps(Profile, Pkgs, Packages, Upgrade, Seen, State) ->
     %% Create app_info record for each pkg dep
-    DepsDir = rebar_dir:deps_dir(State),
+    DepsDir = profile_dep_dir(State, Profile),
     {Solved, _, State1}
         = lists:foldl(fun(Pkg, {Acc, SeenAcc, StateAcc}) ->
                         handle_pkg_dep(Profile, Pkg, Packages, Upgrade, DepsDir, Acc, SeenAcc, StateAcc)
@@ -214,7 +213,7 @@ handle_pkg_dep(Profile, Pkg, Packages, Upgrade, DepsDir, Fetched, Seen, State) -
     AppInfo = package_to_app(DepsDir, Packages, Pkg),
     Level = rebar_app_info:dep_level(AppInfo),
     {NewSeen, NewState} = maybe_lock(Profile, AppInfo, Seen, State, Level),
-    {_, AppInfo1} = maybe_fetch(AppInfo, Upgrade, Seen, NewState),
+    {_, AppInfo1} = maybe_fetch(AppInfo, Profile, Upgrade, Seen, NewState),
     {[AppInfo1 | Fetched], NewSeen, NewState}.
 
 maybe_lock(Profile, AppInfo, Seen, State, Level) ->
@@ -252,7 +251,7 @@ package_to_app(DepsDir, Packages, {Name, Vsn, Level}) ->
                        || {PkgName,PkgVsn} <- proplists:get_value(<<"deps">>, P, [])],
             {ok, AppInfo} = rebar_app_info:new(Name, Vsn),
             AppInfo1 = rebar_app_info:deps(AppInfo, PkgDeps),
-            AppInfo2 = rebar_app_info:dir(AppInfo1, rebar_dir:deps_dir(DepsDir, Name)),
+            AppInfo2 = rebar_app_info:dir(AppInfo1, filename:join([DepsDir, Name])),
             AppInfo3 = rebar_app_info:dep_level(AppInfo2, Level),
             rebar_app_info:source(AppInfo3, {pkg, Name, Vsn})
     end.
@@ -278,7 +277,7 @@ update_src_dep(AppInfo, Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Upgrad
     Name = rebar_app_info:name(AppInfo),
     case sets:is_element(Name, Seen) of
         true ->
-            update_seen_src_dep(AppInfo, Level,
+            update_seen_src_dep(AppInfo, Profile, Level,
                                 SrcDeps, PkgDeps, SrcApps,
                                 State, Upgrade, Seen, BaseLocks, Locks);
         false ->
@@ -288,7 +287,13 @@ update_src_dep(AppInfo, Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Upgrad
 
     end.
 
-update_seen_src_dep(AppInfo, Level, SrcDeps, PkgDeps, SrcApps, State, Upgrade, Seen, BaseLocks, Locks) ->
+profile_dep_dir(State, Profile) ->
+    case Profile of
+        default -> filename:join([rebar_dir:profile_dir(State, [default]), rebar_state:get(State, deps_dir, ?DEFAULT_DEPS_DIR)]);
+        _ -> rebar_dir:deps_dir(State)
+    end.
+
+update_seen_src_dep(AppInfo, Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Upgrade, Seen, BaseLocks, Locks) ->
     Name = rebar_app_info:name(AppInfo),
     %% If seen from lock file don't print warning about skipping
     case lists:keymember(Name, 1, BaseLocks) of
@@ -303,7 +308,7 @@ update_seen_src_dep(AppInfo, Level, SrcDeps, PkgDeps, SrcApps, State, Upgrade, S
             {SrcDeps, PkgDeps, SrcApps, State, Seen, Locks};
         true ->
             {NewSrcDeps, NewPkgDeps, NewSrcApps, NewState, NewLocks}
-                = handle_dep(AppInfo, SrcDeps, PkgDeps, SrcApps,
+                = handle_dep(AppInfo, Profile, SrcDeps, PkgDeps, SrcApps,
                              Level, State, Locks),
             {NewSrcDeps, NewPkgDeps, NewSrcApps, NewState, Seen, NewLocks}
     end.
@@ -313,22 +318,22 @@ update_unseen_src_dep(AppInfo, Profile, Level, SrcDeps, PkgDeps, SrcApps, State,
     {NewSrcDeps, NewPkgDeps, NewSrcApps, State2, NewLocks}
         = case Upgrade of
             true ->
-                handle_upgrade(AppInfo, SrcDeps, PkgDeps, SrcApps,
+                handle_upgrade(AppInfo, Profile, SrcDeps, PkgDeps, SrcApps,
                                Level, State1, Locks);
             _ ->
-                {_, AppInfo1} = maybe_fetch(AppInfo, false, Seen, State1),
-                handle_dep(AppInfo1, SrcDeps, PkgDeps, SrcApps,
+                {_, AppInfo1} = maybe_fetch(AppInfo, Profile, false, Seen, State1),
+                handle_dep(AppInfo1, Profile, SrcDeps, PkgDeps, SrcApps,
                            Level, State1, Locks)
         end,
     {NewSrcDeps, NewPkgDeps, NewSrcApps, State2, NewSeen, NewLocks}.
 
-handle_upgrade(AppInfo, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
+handle_upgrade(AppInfo, Profile, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
     Name = rebar_app_info:name(AppInfo),
     case lists:keyfind(Name, 1, Locks) of
         false ->
-            case maybe_fetch(AppInfo, true, sets:new(), State) of
+            case maybe_fetch(AppInfo, Profile, true, sets:new(), State) of
                 {true, AppInfo1} ->
-                    handle_dep(AppInfo1, SrcDeps, PkgDeps, SrcApps,
+                    handle_dep(AppInfo1, Profile, SrcDeps, PkgDeps, SrcApps,
                                Level, State, Locks);
 
                 {false, AppInfo1} ->
@@ -338,8 +343,8 @@ handle_upgrade(AppInfo, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
             {[AppInfo|SrcDeps], PkgDeps, SrcApps, State, Locks}
     end.
 
-handle_dep(AppInfo, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
-    DepsDir = rebar_dir:deps_dir(State),
+handle_dep(AppInfo, Profile, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
+    DepsDir = profile_dep_dir(State, Profile),
     {AppInfo1, NewSrcDeps, NewPkgDeps, NewLocks, State1} =
         handle_dep(State, DepsDir, AppInfo, Locks, Level),
     AppInfo2 = rebar_app_info:dep_level(AppInfo1, Level),
@@ -374,9 +379,9 @@ handle_dep(State, DepsDir, AppInfo, Locks, Level) ->
     {SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps, S3, Locks, Level),
     {AppInfo2, SrcDeps, PkgDeps, Locks++NewLocks, State1}.
 
--spec maybe_fetch(rebar_app_info:t(), boolean() | {true, binary(), integer()},
+-spec maybe_fetch(rebar_app_info:t(), atom(), boolean() | {true, binary(), integer()},
                   sets:set(binary()), rebar_state:t()) -> {boolean(), rebar_app_info:t()}.
-maybe_fetch(AppInfo, Upgrade, Seen, State) ->
+maybe_fetch(AppInfo, Profile, Upgrade, Seen, State) ->
     AppDir = ec_cnv:to_list(rebar_app_info:dir(AppInfo)),
     %% Don't fetch dep if it exists in the _checkouts dir
     case rebar_app_info:is_checkout(AppInfo) of
@@ -385,22 +390,27 @@ maybe_fetch(AppInfo, Upgrade, Seen, State) ->
         false ->
             case rebar_app_discover:find_app(AppDir, all) of
                 false ->
-                    case in_default(AppInfo, State) of
+                    case already_in_default(AppInfo, State) of
                         false ->
-                            {fetch_app(AppInfo, AppDir, State), AppInfo};
+                            case fetch_app(AppInfo, AppDir, State) of
+                                true ->
+                                    maybe_symlink_default(State, Profile, AppDir, AppInfo),
+                                    {true, update_app_info(AppInfo)};
+                                Other ->
+                                    {Other, AppInfo}
+                            end;
                         {true, FoundApp} ->
                             %% Preserve the state we created with overrides
                             AppState = rebar_app_info:state(AppInfo),
                             FoundApp1 = rebar_app_info:state(FoundApp, AppState),
-                            ?INFO("Linking ~s to ~s", [rebar_app_info:dir(FoundApp1), AppDir]),
-                            filelib:ensure_dir(AppDir),
-                            rebar_file_utils:symlink_or_copy(rebar_app_info:dir(FoundApp1), AppDir),
+                            symlink_dep(rebar_app_info:dir(FoundApp1), AppDir),
                             {true, FoundApp1}
                     end;
                 {true, AppInfo1} ->
                     %% Preserve the state we created with overrides
                     AppState = rebar_app_info:state(AppInfo),
                     AppInfo2 = rebar_app_info:state(AppInfo1, AppState),
+                    maybe_symlink_default(State, Profile, AppDir, AppInfo2),
                     case sets:is_element(rebar_app_info:name(AppInfo), Seen) of
                         true ->
                             {false, AppInfo2};
@@ -410,11 +420,42 @@ maybe_fetch(AppInfo, Upgrade, Seen, State) ->
             end
     end.
 
-in_default(AppInfo, State) ->
+already_in_default(AppInfo, State) ->
     Name = ec_cnv:to_list(rebar_app_info:name(AppInfo)),
     DefaultAppDir = filename:join([rebar_state:get(State, base_dir), "default", "lib", Name]),
     rebar_app_discover:find_app(DefaultAppDir, all).
 
+needs_symlinking(State, Profile) ->
+    case {rebar_state:current_profiles(State), Profile} of
+        {[default], default} ->
+            %% file will be in default already -- this is the only run we have
+            false;
+        {_, default} ->
+            %% file fetched to default, needs to be linked to the current
+            %% run's directory.
+            true;
+        _ ->
+            %% File fetched to the right directory already
+            false
+    end.
+
+maybe_symlink_default(State, Profile, AppDir, AppInfo) ->
+    case needs_symlinking(State, Profile) of
+        true ->
+            SymDir = filename:join([rebar_dir:deps_dir(State),
+                                    rebar_app_info:name(AppInfo)]),
+            symlink_dep(AppDir, SymDir),
+            true;
+        false ->
+            false
+    end.
+
+
+symlink_dep(From, To) ->
+    ?INFO("Linking ~s to ~s", [From, To]),
+    filelib:ensure_dir(To),
+    rebar_file_utils:symlink_or_copy(From, To).
+
 -spec parse_deps(binary(), list(), rebar_state:t(), list(), integer()) -> {[rebar_app_info:t()], [pkg_dep()]}.
 parse_deps(DepsDir, Deps, State, Locks, Level) ->
     lists:foldl(fun(Dep, Acc) ->
@@ -521,6 +562,15 @@ fetch_app(AppInfo, AppDir, State) ->
             Result
     end.
 
+update_app_info(AppInfo) ->
+    AppDetails = rebar_app_info:app_details(AppInfo),
+    Applications = proplists:get_value(applications, AppDetails, []),
+    IncludedApplications = proplists:get_value(included_applications, AppDetails, []),
+    AppInfo1 = rebar_app_info:applications(
+                 rebar_app_info:app_details(AppInfo, AppDetails),
+                 IncludedApplications++Applications),
+    rebar_app_info:valid(AppInfo1, false).
+
 maybe_upgrade(AppInfo, AppDir, false, State) ->
     Source = rebar_app_info:source(AppInfo),
     rebar_fetch:needs_update(AppDir, Source, State);
diff --git a/src/rebar_prv_lock.erl b/src/rebar_prv_lock.erl
index 5536ec9..6fdd743 100644
--- a/src/rebar_prv_lock.erl
+++ b/src/rebar_prv_lock.erl
@@ -23,30 +23,31 @@ init(State) ->
                                                                {deps, ?DEPS},
                                                                {example, ""},
                                                                {short_desc, "Locks dependencies."},
-                                                               {desc, info("Locks dependencies")},
+                                                               {desc, "Locks dependencies"},
                                                                {opts, []}])),
     {ok, State1}.
 
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
-    AllDeps = rebar_state:lock(State),
-    Locks = [begin
-                 Dir = rebar_app_info:dir(Dep),
-                 Source = rebar_app_info:source(Dep),
-
-                 %% If source is tuple it is a source dep
-                 %% e.g. {git, "git://github.com/ninenines/cowboy.git", "master"}
-                 {rebar_app_info:name(Dep)
-                 ,rebar_fetch:lock_source(Dir, Source, State)
-                 ,rebar_app_info:dep_level(Dep)}
-             end || Dep <- AllDeps, not(rebar_app_info:is_checkout(Dep))],
+    Locks = build_locks(State),
     Dir = rebar_state:dir(State),
-    file:write_file(filename:join(Dir, ?LOCK_FILE), io_lib:format("~p.~n", [Locks])),
+    file:write_file(filename:join(Dir, ?LOCK_FILE),
+                    io_lib:format("~p.~n", [Locks])),
     {ok, State}.
 
 -spec format_error(any()) -> iolist().
 format_error(Reason) ->
     io_lib:format("~p", [Reason]).
 
-info(_) ->
-    "".
+build_locks(State) ->
+    AllDeps = rebar_state:lock(State),
+    [begin
+        Dir = rebar_app_info:dir(Dep),
+        Source = rebar_app_info:source(Dep),
+
+        %% If source is tuple it is a source dep
+        %% e.g. {git, "git://github.com/ninenines/cowboy.git", "master"}
+        {rebar_app_info:name(Dep)
+        ,rebar_fetch:lock_source(Dir, Source, State)
+        ,rebar_app_info:dep_level(Dep)}
+     end || Dep <- AllDeps, not(rebar_app_info:is_checkout(Dep))].
diff --git a/src/rebar_prv_release.erl b/src/rebar_prv_release.erl
index c9a9c0b..595280c 100644
--- a/src/rebar_prv_release.erl
+++ b/src/rebar_prv_release.erl
@@ -35,8 +35,9 @@ do(State) ->
     Caller = rebar_state:get(State, caller, api),
     Options = rebar_state:command_args(State),
     DepsDir = rebar_dir:deps_dir(State),
+    ProjectAppDirs = lists:delete(".", ?DEFAULT_PROJECT_APP_DIRS),
     LibDirs = rebar_utils:filtermap(fun ec_file:exists/1,
-                                   [DepsDir | lists:delete(".", ?DEFAULT_PROJECT_APP_DIRS)]),
+                                   [?DEFAULT_CHECKOUTS_DIR, DepsDir | ProjectAppDirs]),
     OutputDir = filename:join(rebar_dir:base_dir(State), ?DEFAULT_RELEASE_DIR),
     AllOptions = string:join(["release" | Options], " "),
     try
diff --git a/src/rebar_prv_shell.erl b/src/rebar_prv_shell.erl
index ed75b30..6153952 100644
--- a/src/rebar_prv_shell.erl
+++ b/src/rebar_prv_shell.erl
@@ -92,7 +92,9 @@ shell(State) ->
     %% times). removes at most the error_logger added by init and the
     %% error_logger added by the tty handler
     ok = remove_error_handler(3),
-    %% add test paths
+    %% Add deps to path
+    code:add_pathsa(rebar_state:code_paths(State, all_deps)),
+    %% add project app test paths
     ok = add_test_paths(State),
     %% this call never returns (until user quits shell)
     timer:sleep(infinity).
@@ -121,10 +123,9 @@ wait_until_user_started(Timeout) ->
 
 add_test_paths(State) ->
     lists:foreach(fun(App) ->
-        AppDir = rebar_app_info:out_dir(App),
-        %% ignore errors resulting from non-existent directories
-        _ = code:add_path(filename:join([AppDir, "ebin"])),
-        _ = code:add_path(filename:join([AppDir, "test"]))
-    end, rebar_state:project_apps(State)),
+                          AppDir = rebar_app_info:out_dir(App),
+                          %% ignore errors resulting from non-existent directories
+                          _ = code:add_path(filename:join([AppDir, "test"]))
+                  end, rebar_state:project_apps(State)),
     _ = code:add_path(filename:join([rebar_dir:base_dir(State), "test"])),
     ok.
diff --git a/src/rebar_prv_tar.erl b/src/rebar_prv_tar.erl
index 019036e..f7557bd 100644
--- a/src/rebar_prv_tar.erl
+++ b/src/rebar_prv_tar.erl
@@ -35,8 +35,9 @@ do(State) ->
     Caller = rebar_state:get(State, caller, api),
     Options = rebar_state:command_args(State),
     DepsDir = rebar_dir:deps_dir(State),
+    ProjectAppDirs = lists:delete(".", ?DEFAULT_PROJECT_APP_DIRS),
     LibDirs = rebar_utils:filtermap(fun ec_file:exists/1,
-                                   [DepsDir | lists:delete(".", ?DEFAULT_PROJECT_APP_DIRS)]),
+                                   [?DEFAULT_CHECKOUTS_DIR, DepsDir | ProjectAppDirs]),
     OutputDir = filename:join(rebar_dir:base_dir(State), ?DEFAULT_RELEASE_DIR),
     AllOptions = string:join(["release", "tar" | Options], " "),
     case rebar_state:get(State, relx, []) of
diff --git a/src/rebar_prv_unlock.erl b/src/rebar_prv_unlock.erl
new file mode 100644
index 0000000..dc9fe11
--- /dev/null
+++ b/src/rebar_prv_unlock.erl
@@ -0,0 +1,84 @@
+-module(rebar_prv_unlock).
+
+-behaviour(provider).
+
+-export([init/1,
+         do/1,
+         format_error/1]).
+
+-include("rebar.hrl").
+-include_lib("providers/include/providers.hrl").
+
+-define(PROVIDER, unlock).
+-define(DEPS, []).
+
+%% ===================================================================
+%% Public API
+%% ===================================================================
+
+-spec init(rebar_state:t()) -> {ok, rebar_state:t()}.
+init(State) ->
+    State1 = rebar_state:add_provider(
+        State,
+        providers:create([{name, ?PROVIDER},
+                          {module, ?MODULE},
+                          {bare, false},
+                          {deps, ?DEPS},
+                          {example, ""},
+                          {short_desc, "Unlock dependencies."},
+                          {desc, "Unlock project dependencies. Mentioning no application "
+                                 "will unlock all dependencies. To unlock specific dependencies, "
+                                 "their name can be listed in the command."},
+                          {opts, [
+                            {package, undefined, undefined, string,
+                             "List of packages to upgrade. If not specified, all dependencies are upgraded."}
+                          ]}
+                         ])
+    ),
+    {ok, State1}.
+
+do(State) ->
+    Dir = rebar_state:dir(State),
+    LockFile = filename:join(Dir, ?LOCK_FILE),
+    case file:consult(LockFile) of
+        {error, enoent} ->
+            %% Our work is done.
+            {ok, State};
+        {error, Reason} ->
+            ?PRV_ERROR({file,Reason});
+        {ok, [Locks]} ->
+            case handle_unlocks(State, Locks, LockFile) of
+                ok ->
+                    {ok, State};
+                {error, Reason} ->
+                    ?PRV_ERROR({file,Reason})
+            end;
+        {ok, _Other} ->
+            ?PRV_ERROR(unknown_lock_format)
+    end.
+
+-spec format_error(any()) -> iolist().
+format_error({file, Reason}) ->
+    io_lib:format("Lock file editing failed for reason ~p", [Reason]);
+format_error(unknown_lock_format) ->
+    "Lock file format unknown";
+format_error(Reason) ->
+    io_lib:format("~p", [Reason]).
+
+handle_unlocks(State, Locks, LockFile) ->
+    {Args, _} = rebar_state:command_parsed_args(State),
+    Names = parse_names(ec_cnv:to_binary(proplists:get_value(package, Args, <<"">>))),
+    case [Lock || Lock = {Name, _, _} <- Locks, not lists:member(Name, Names)] of
+        [] ->
+            file:delete(LockFile);
+        _ when Names =:= [] -> % implicitly all locks
+            file:delete(LockFile);
+        NewLocks ->
+            file:write_file(LockFile, io_lib:format("~p.~n", [NewLocks]))
+    end.
+
+parse_names(Bin) ->
+    case lists:usort(re:split(Bin, <<" *, *">>, [trim])) of
+        [<<"">>] -> []; % nothing submitted
+        Other -> Other
+    end.
diff --git a/src/rebar_prv_update.erl b/src/rebar_prv_update.erl
index 6cdabeb..d0ff889 100644
--- a/src/rebar_prv_update.erl
+++ b/src/rebar_prv_update.erl
@@ -91,7 +91,7 @@ hex_to_graph(Filename) ->
     {Dict1, Graph}.
 
 update_graph(Pkg, PkgVsn, Deps, HexRegistry, Graph) ->
-    lists:foldl(fun([Dep, DepVsn, _, _], DepsListAcc) ->
+    lists:foldl(fun([Dep, DepVsn, false, _AppName | _], DepsListAcc) ->
                         case DepVsn of
                             <<"~> ", Vsn/binary>> ->
                                 HighestDepVsn = rebar_packages:find_highest_matching(Dep, Vsn, HexRegistry),
@@ -100,5 +100,7 @@ update_graph(Pkg, PkgVsn, Deps, HexRegistry, Graph) ->
                             Vsn ->
                                 digraph:add_edge(Graph, {Pkg, PkgVsn}, {Dep, Vsn}),
                                 [{Dep, Vsn} | DepsListAcc]
-                        end
+                        end;
+                   ([_Dep, _DepVsn, true, _AppName | _], DepsListAcc) ->
+                        DepsListAcc
                 end, [], Deps).
diff --git a/src/rebar_prv_upgrade.erl b/src/rebar_prv_upgrade.erl
index 37914a7..d7d2921 100644
--- a/src/rebar_prv_upgrade.erl
+++ b/src/rebar_prv_upgrade.erl
@@ -91,29 +91,38 @@ parse_names(Bin, Locks) ->
 prepare_locks([], _, Locks, Unlocks) ->
     {Locks, Unlocks};
 prepare_locks([Name|Names], Deps, Locks, Unlocks) ->
+    AtomName = binary_to_atom(Name, utf8),
     case lists:keyfind(Name, 1, Locks) of
         {_, _, 0} = Lock ->
-            AtomName = binary_to_atom(Name, utf8),
             case lists:keyfind(AtomName, 1, Deps) of
                 false ->
                     ?PRV_ERROR({unknown_dependency, Name});
                 Dep ->
-                    Source = case Dep of
-                        {_, Src} -> Src;
-                        {_, _, Src} -> Src
-                    end,
-                    {NewLocks, NewUnlocks} = unlock_higher_than(0, Locks -- [Lock]),
-                    prepare_locks(Names,
-                                  Deps,
-                                  NewLocks,
+                    {Source, NewLocks, NewUnlocks} = prepare_lock(Dep, Lock, Locks),
+                    prepare_locks(Names, Deps, NewLocks,
+                                  [{Name, Source, 0} | NewUnlocks ++ Unlocks])
+            end;
+        {_, _, Level} = Lock when Level > 0 ->
+            case lists:keyfind(AtomName, 1, Deps) of
+                false ->
+                    ?PRV_ERROR({transitive_dependency, Name});
+                Dep -> % Dep has been promoted
+                    {Source, NewLocks, NewUnlocks} = prepare_lock(Dep, Lock, Locks),
+                    prepare_locks(Names, Deps, NewLocks,
                                   [{Name, Source, 0} | NewUnlocks ++ Unlocks])
             end;
-        {_, _, Level} when Level > 0 ->
-            ?PRV_ERROR({transitive_dependency, Name});
         false ->
             ?PRV_ERROR({unknown_dependency, Name})
     end.
 
+prepare_lock(Dep, Lock, Locks) ->
+    Source = Source = case Dep of
+        {_, Src} -> Src;
+        {_, _, Src} -> Src
+    end,
+    {NewLocks, NewUnlocks} = unlock_higher_than(0, Locks -- [Lock]),
+    {Source, NewLocks, NewUnlocks}.
+
 top_level_deps(Deps, Locks) ->
     [Dep || Dep <- Deps, lists:keymember(0, 3, Locks)].
 
diff --git a/src/rebar_prv_xref.erl b/src/rebar_prv_xref.erl
index 67cd554..1d1afa0 100644
--- a/src/rebar_prv_xref.erl
+++ b/src/rebar_prv_xref.erl
@@ -36,7 +36,8 @@ init(State) ->
 
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
-    {OriginalPath, XrefChecks} = prepare(State),
+    code:add_pathsa(rebar_state:code_paths(State, all_deps)),
+    XrefChecks = prepare(State),
 
     %% Run xref checks
     ?INFO("Running cross reference analysis...", []),
@@ -45,9 +46,8 @@ do(State) ->
     %% Run custom queries
     QueryChecks = rebar_state:get(State, xref_queries, []),
     QueryResults = lists:foldl(fun check_query/2, [], QueryChecks),
-
-    ok = cleanup(OriginalPath),
-
+    stopped = xref:stop(xref),
+    rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
     case XrefResults =:= [] andalso QueryResults =:= [] of
         true ->
             {ok, State};
@@ -100,10 +100,6 @@ prepare(State) ->
     [{ok, _} = xref:add_directory(xref, rebar_app_info:ebin_dir(App))
      || App <- rebar_state:project_apps(State)],
 
-    %% Save the code path prior to doing any further code path
-    %% manipulation
-    OriginalPath = code:get_path(),
-
     %% Get list of xref checks we want to run
     ConfXrefChecks = rebar_state:get(State, xref_checks,
                                      [exports_not_used,
@@ -112,15 +108,7 @@ prepare(State) ->
     XrefChecks = sets:to_list(sets:intersection(
                                 sets:from_list(?SUPPORTED_XREFS),
                                 sets:from_list(ConfXrefChecks))),
-    {OriginalPath, XrefChecks}.
-
-cleanup(Path) ->
-    %% Restore the code path using the provided path
-    true = rebar_utils:cleanup_code_path(Path),
-
-    %% Stop xref
-    stopped = xref:stop(xref),
-    ok.
+    XrefChecks.
 
 xref_checks(XrefChecks) ->
     lists:foldl(fun run_xref_check/2, [], XrefChecks).
diff --git a/src/rebar_state.erl b/src/rebar_state.erl
index 9b8d261..46c870e 100644
--- a/src/rebar_state.erl
+++ b/src/rebar_state.erl
@@ -3,6 +3,8 @@
 -export([new/0, new/1, new/2, new/3,
          get/2, get/3, set/3,
 
+         code_paths/2, code_paths/3, update_code_paths/3,
+
          opts/1, opts/2,
          default/1, default/2,
 
@@ -22,7 +24,7 @@
 
          project_apps/1, project_apps/2,
          deps_to_build/1, deps_to_build/2,
-         all_deps/1, all_deps/2,
+         all_deps/1, all_deps/2, update_all_deps/2,
          namespace/1, namespace/2,
 
          deps_names/1,
@@ -40,6 +42,7 @@
 
 -record(state_t, {dir                               :: file:name(),
                   opts                = dict:new()  :: rebar_dict(),
+                  code_paths          = dict:new()  :: rebar_dict(),
                   default             = dict:new()  :: rebar_dict(),
                   escript_path                      :: undefined | file:filename_all(),
 
@@ -62,7 +65,7 @@
 
 -export_type([t/0]).
 
--type t() :: record(state_t).
+-type t() :: #state_t{}.
 
 -spec new() -> t().
 new() ->
@@ -132,6 +135,25 @@ default(#state_t{default=Opts}) ->
 default(State, Opts) ->
     State#state_t{default=Opts}.
 
+code_paths(#state_t{code_paths=CodePaths}, Key) ->
+    case dict:find(Key, CodePaths) of
+        {ok, CodePath} ->
+            CodePath;
+        _ ->
+            []
+    end.
+
+code_paths(State=#state_t{code_paths=CodePaths}, Key, CodePath) ->
+    State#state_t{code_paths=dict:store(Key, CodePath, CodePaths)}.
+
+update_code_paths(State=#state_t{code_paths=CodePaths}, Key, CodePath) ->
+    case dict:is_key(Key, CodePaths) of
+        true ->
+            State#state_t{code_paths=dict:append_list(Key, CodePath, CodePaths)};
+        false ->
+            State#state_t{code_paths=dict:store(Key, CodePath, CodePaths)}
+    end.
+
 opts(#state_t{opts=Opts}) ->
     Opts.
 
@@ -310,6 +332,9 @@ all_deps(#state_t{all_deps=Apps}) ->
 all_deps(State=#state_t{}, NewApps) ->
     State#state_t{all_deps=NewApps}.
 
+update_all_deps(State=#state_t{all_deps=Apps}, NewApps) ->
+    State#state_t{all_deps=Apps++NewApps}.
+
 namespace(#state_t{namespace=Namespace}) ->
     Namespace.
 
diff --git a/src/rebar_templater.erl b/src/rebar_templater.erl
index 75cbb87..746e440 100644
--- a/src/rebar_templater.erl
+++ b/src/rebar_templater.erl
@@ -266,17 +266,29 @@ replace_var([H|T], Acc, Vars) ->
 
 %% Load a list of all the files in the escript and on disk
 find_templates(State) ->
-    %% Cache the files since we'll potentially need to walk it several times
-    %% over the course of a run.
-    Files = cache_escript_files(State),
+    DiskTemplates = find_disk_templates(State),
+    {MainTemplates, Files} =
+        case rebar_state:escript_path(State) of
+            undefined ->
+                {find_priv_templates(State), []};
+            _ ->
+                %% Cache the files since we'll potentially need to walk it several times
+                %% over the course of a run.
+                F = cache_escript_files(State),
+                {find_escript_templates(F), F}
+        end,
+    AvailTemplates = find_available_templates(DiskTemplates,
+                                              MainTemplates),
+    ?DEBUG("Available templates: ~p\n", [AvailTemplates]),
+    {AvailTemplates, Files}.
 
-    %% Build a list of available templates
+find_available_templates(TemplateList1, TemplateList2) ->
     AvailTemplates = prioritize_templates(
-        tag_names(find_disk_templates(State)),
-        tag_names(find_escript_templates(Files))),
+                       tag_names(TemplateList1),
+                       tag_names(TemplateList2)),
 
     ?DEBUG("Available templates: ~p\n", [AvailTemplates]),
-    {AvailTemplates, Files}.
+    AvailTemplates.
 
 %% Scan the current escript for available files
 cache_escript_files(State) ->
@@ -293,6 +305,12 @@ find_escript_templates(Files) ->
      || {Name, _Bin} <- Files,
         re:run(Name, ?TEMPLATE_RE, [{capture, none}]) == match].
 
+find_priv_templates(State) ->
+    OtherTemplates = rebar_utils:find_files(code:priv_dir(rebar), ?TEMPLATE_RE),
+    HomeFiles = rebar_utils:find_files(rebar_dir:template_dir(State),
+                                       ?TEMPLATE_RE, true), % recursive
+    [{file, F} || F <- OtherTemplates ++ HomeFiles].
+
 %% Fetch template indexes that sit on disk in the user's HOME
 find_disk_templates(State) ->
     OtherTemplates = find_other_templates(State),
@@ -394,7 +412,7 @@ write_file(Output, Data, Force) ->
 -spec make_template_name(string(), term()) -> module().
 make_template_name(Base, Value) ->
     %% Seed so we get different values each time
-    random:seed(erlang:now()),
+    random:seed(os:timestamp()),
     Hash = erlang:phash2(Value),
     Ran = random:uniform(10000000),
     erlang:list_to_atom(Base ++ "_" ++
diff --git a/src/rebar_utils.erl b/src/rebar_utils.erl
index bc2e4ac..49f7ad7 100644
--- a/src/rebar_utils.erl
+++ b/src/rebar_utils.erl
@@ -42,7 +42,6 @@
          erl_to_mod/1,
          beams/1,
          find_executable/1,
-         expand_code_path/0,
          vcs_vsn/2,
          deprecated/3,
          deprecated/4,
@@ -177,13 +176,6 @@ find_executable(Name) ->
             "\"" ++ filename:nativename(Path) ++ "\""
     end.
 
-%% Convert all the entries in the code path to absolute paths.
-expand_code_path() ->
-    CodePath = lists:foldl(fun(Path, Acc) ->
-                                   [filename:absname(Path) | Acc]
-                           end, [], code:get_path()),
-    code:set_path(lists:reverse(CodePath)).
-
 deprecated(Old, New, Opts, When) when is_list(Opts) ->
     case lists:member(Old, Opts) of
         true ->