wip: move state into app_info

src/rebar_app_discover.erl

@@ -89,12 +89,13 @@ merge_deps(AppInfo, State) ->
 
     AppState2 = rebar_state:set(AppState1, artifacts, []),
     AppInfo1 = rebar_app_info:state(AppInfo, AppState2),
+    AppInfo2 = rebar_app_info:opts(AppInfo1, rebar_state:opts(AppState2)),
 
     State1 = lists:foldl(fun(Profile, StateAcc) ->
                                  handle_profile(Profile, Name, AppState1, StateAcc)
                          end, State, lists:reverse(CurrentProfiles)),
 
-    {AppInfo1, State1}.
+    {AppInfo2, State1}.
 
 handle_profile(Profile, Name, AppState, State) ->
     TopParsedDeps = rebar_state:get(State, {parsed_deps, Profile}, {[], []}),

src/rebar_app_info.erl

@@ -5,6 +5,7 @@
          new/3,
          new/4,
          new/5,
+         update_opts/3,
          discover/1,
          name/1,
          name/2,
@@ -35,6 +36,13 @@
          dir/2,
          out_dir/1,
          out_dir/2,
+         default/1,
+         default/2,
+         opts/1,
+         opts/2,
+         get/2,
+         get/3,
+         set/3,
          resource_type/1,
          resource_type/2,
          source/1,
@@ -47,9 +55,20 @@
          is_checkout/1,
          is_checkout/2,
          valid/1,
-         valid/2]).
+         valid/2,
+
+         has_all_artifacts/1,
+
+         apply_overrides/2,
+         add_to_profile/3,
+         apply_profiles/2,
+         deduplicate/1,
+         do_deduplicate/2,
+         merge_opts/3,
+         merge_opts/2]).
 
 -include("rebar.hrl").
+-include_lib("providers/include/providers.hrl").
 
 -export_type([t/0]).
 
@@ -64,6 +83,8 @@
                      applications=[]    :: list(),
                      deps=[]            :: list(),
                      profiles=[default] :: [atom()],
+                     default=dict:new() :: rebar_dict(),
+                     opts=dict:new()    :: rebar_dict(),
                      dep_level=0        :: integer(),
                      dir                :: file:name(),
                      out_dir            :: file:name(),
@@ -125,6 +146,36 @@ new(Parent, AppName, Vsn, Dir, Deps) ->
                      out_dir=ec_cnv:to_list(Dir),
                      deps=Deps}}.
 
+update_opts(AppInfo, Opts, Config) ->
+    LockDeps = case resource_type(AppInfo) of
+                   pkg ->
+                       Deps = deps(AppInfo),
+                       [{{locks, default}, Deps}, {{deps, default}, Deps}];
+                   _ ->
+                       deps_from_config(dir(AppInfo), Config)
+               end,
+
+    Plugins = proplists:get_value(plugins, Config, []),
+    Terms = LockDeps++[{{plugins, default}, Plugins} | Config],
+    true = rebar_config:verify_config_format(Terms),
+    LocalOpts = dict:from_list(Terms),
+
+    NewOpts = merge_opts(LocalOpts, Opts),
+
+    AppInfo#app_info_t{opts=NewOpts
+                      ,default=NewOpts}.
+
+deps_from_config(Dir, Config) ->
+    case rebar_config:consult_lock_file(filename:join(Dir, ?LOCK_FILE)) of
+        [D] ->
+            %% We want the top level deps only from the lock file.
+            %% This ensures deterministic overrides for configs.
+            Deps = [X || X <- D, element(3, X) =:= 0],
+            [{{locks, default}, D}, {{deps, default}, Deps}];
+        _ ->
+            [{{deps, default}, proplists:get_value(deps, Config, [])}]
+    end.
+
 %% @doc discover a complete version of the app info with all fields set.
 -spec discover(file:filename_all()) -> {ok, t()} | not_found.
 discover(Dir) ->
@@ -151,6 +202,34 @@ config(#app_info_t{config=Config}) ->
 config(AppInfo=#app_info_t{}, Config) ->
     AppInfo#app_info_t{config=Config}.
 
+opts(#app_info_t{opts=Opts}) ->
+    Opts.
+
+opts(AppInfo, Opts) ->
+    AppInfo#app_info_t{opts=Opts}.
+
+default(#app_info_t{default=Default}) ->
+    Default.
+
+default(AppInfo, Default) ->
+    AppInfo#app_info_t{default=Default}.
+
+get(AppInfo, Key) ->
+    {ok, Value} = dict:find(Key, AppInfo#app_info_t.opts),
+    Value.
+
+get(AppInfo, Key, Default) ->
+    case dict:find(Key, AppInfo#app_info_t.opts) of
+        {ok, Value} ->
+            Value;
+        error ->
+            Default
+    end.
+
+-spec set(t(), any(), any()) -> t().
+set(AppInfo=#app_info_t{opts=Opts}, Key, Value) ->
+    AppInfo#app_info_t{opts = dict:store(Key, Value, Opts)}.
+
 -spec app_file_src(t()) -> file:filename_all() | undefined.
 app_file_src(#app_info_t{app_file_src=undefined, dir=Dir, name=Name}) ->
     AppFileSrc = filename:join([ec_cnv:to_list(Dir), "src", ec_cnv:to_list(Name)++".app.src"]),
@@ -338,9 +417,9 @@ is_checkout(#app_info_t{is_checkout=IsCheckout}) ->
     IsCheckout.
 
 -spec valid(t()) -> boolean().
-valid(AppInfo=#app_info_t{valid=undefined, state=State}) ->
+valid(AppInfo=#app_info_t{valid=undefined}) ->
     case rebar_app_utils:validate_application_info(AppInfo) =:= true
-        andalso rebar_state:has_all_artifacts(State) =:= true of
+        andalso has_all_artifacts(AppInfo) =:= true of
         true ->
             true;
         _ ->
@@ -352,3 +431,158 @@ valid(#app_info_t{valid=Valid}) ->
 -spec valid(t(), boolean()) -> t().
 valid(AppInfo=#app_info_t{}, Valid) ->
     AppInfo#app_info_t{valid=Valid}.
+
+-spec has_all_artifacts(#app_info_t{}) -> true | {false, file:filename()}.
+has_all_artifacts(AppInfo) ->
+    Artifacts = rebar_app_info:get(AppInfo, artifacts, []),
+    Dir = dir(AppInfo),
+    all(Dir, Artifacts).
+
+all(_, []) ->
+    true;
+all(Dir, [File|Artifacts]) ->
+    case filelib:is_regular(filename:join(Dir, File)) of
+        false ->
+            ?DEBUG("Missing artifact ~s", [filename:join(Dir, File)]),
+            {false, File};
+        true ->
+            all(Dir, Artifacts)
+    end.
+
+%%%%%
+
+apply_overrides(AppInfo, Name) ->
+    Overrides = rebar_app_info:get(AppInfo, overrides, []),
+    %Name = binary_to_atom(AppName, utf8),
+
+    %% Inefficient. We want the order we get here though.
+    AppInfo1 = lists:foldl(fun({override, O}, AppInfoAcc) ->
+                                 lists:foldl(fun({deps, Value}, AppInfoAcc1) ->
+                                                     rebar_app_info:set(AppInfoAcc1, {deps,default}, Value);
+                                                ({Key, Value}, AppInfoAcc1) ->
+                                                     rebar_app_info:set(AppInfoAcc1, Key, Value)
+                                             end, AppInfoAcc, O);
+                            (_, AppInfoAcc) ->
+                                 AppInfoAcc
+                         end, AppInfo, Overrides),
+
+    AppInfo2 = lists:foldl(fun({override, N, O}, AppInfoAcc) when N =:= Name ->
+                                 lists:foldl(fun({deps, Value}, AppInfoAcc1) ->
+                                                     rebar_app_info:set(AppInfoAcc1, {deps,default}, Value);
+                                                ({Key, Value}, AppInfoAcc1) ->
+                                                     rebar_app_info:set(AppInfoAcc1, Key, Value)
+                                             end, AppInfoAcc, O);
+                            (_, AppInfoAcc) ->
+                                 AppInfoAcc
+                         end, AppInfo1, Overrides),
+
+    AppInfo3 = lists:foldl(fun({add, N, O}, AppInfoAcc) when N =:= Name ->
+                        lists:foldl(fun({deps, Value}, AppInfoAcc1) ->
+                                            OldValue = rebar_app_info:get(AppInfoAcc1, {deps,default}, []),
+                                            rebar_app_info:set(AppInfoAcc1, {deps,default}, Value++OldValue);
+                                       ({Key, Value}, AppInfoAcc1) ->
+                                            OldValue = rebar_app_info:get(AppInfoAcc1, Key, []),
+                                            rebar_app_info:set(AppInfoAcc1, Key, Value++OldValue)
+                                    end, AppInfoAcc, O);
+                   (_, AppInfoAcc) ->
+                        AppInfoAcc
+                end, AppInfo2, Overrides),
+
+    Opts = opts(AppInfo3),
+    AppInfo3#app_info_t{default=Opts}.
+
+add_to_profile(AppInfo, Profile, KVs) when is_atom(Profile), is_list(KVs) ->
+    Profiles = rebar_app_info:get(AppInfo, profiles, []),
+    ProfileOpts = dict:from_list(proplists:get_value(Profile, Profiles, [])),
+    NewOpts = merge_opts(Profile, dict:from_list(KVs), ProfileOpts),
+    NewProfiles = [{Profile, dict:to_list(NewOpts)}|lists:keydelete(Profile, 1, Profiles)],
+    rebar_app_info:set(AppInfo, profiles, NewProfiles).
+
+apply_profiles(AppInfo, Profile) when not is_list(Profile) ->
+    apply_profiles(AppInfo, [Profile]);
+apply_profiles(AppInfo, [default]) ->
+    AppInfo;
+apply_profiles(AppInfo=#app_info_t{default = Defaults, profiles=CurrentProfiles}, Profiles) ->
+    AppliedProfiles = case Profiles of
+                          %% Head of list global profile is special, only for use by rebar3
+                          %% It does not clash if a user does `rebar3 as global...` but when
+                          %% it is the head we must make sure not to prepend `default`
+                          [global | _] ->
+                              Profiles;
+                          _ ->
+                              deduplicate(CurrentProfiles ++ Profiles)
+                      end,
+
+    ConfigProfiles = rebar_app_info:get(AppInfo, profiles, []),
+
+    NewOpts =
+        lists:foldl(fun(default, OptsAcc) ->
+                            OptsAcc;
+                       (Profile, OptsAcc) ->
+                            case proplists:get_value(Profile, ConfigProfiles, []) of
+                                OptsList when is_list(OptsList) ->
+                                    ProfileOpts = dict:from_list(OptsList),
+                                    merge_opts(Profile, ProfileOpts, OptsAcc);
+                                Other ->
+                                    throw(?PRV_ERROR({profile_not_list, Profile, Other}))
+                            end
+                    end, Defaults, AppliedProfiles),
+    AppInfo#app_info_t{profiles = AppliedProfiles, opts=NewOpts}.
+
+deduplicate(Profiles) ->
+    do_deduplicate(lists:reverse(Profiles), []).
+
+do_deduplicate([], Acc) ->
+    Acc;
+do_deduplicate([Head | Rest], Acc) ->
+    case lists:member(Head, Acc) of
+        true -> do_deduplicate(Rest, Acc);
+        false -> do_deduplicate(Rest, [Head | Acc])
+    end.
+
+merge_opts(Profile, NewOpts, OldOpts) ->
+    Opts = merge_opts(NewOpts, OldOpts),
+
+    Opts2 = case dict:find(plugins, NewOpts) of
+        {ok, Value} ->
+            dict:store({plugins, Profile}, Value, Opts);
+        error ->
+            Opts
+    end,
+
+    case dict:find(deps, NewOpts) of
+        {ok, Value2} ->
+            dict:store({deps, Profile}, Value2, Opts2);
+        error ->
+            Opts2
+    end.
+
+merge_opts(NewOpts, OldOpts) ->
+    dict:merge(fun(deps, _NewValue, OldValue) ->
+                       OldValue;
+                  ({deps, _}, NewValue, _OldValue) ->
+                       NewValue;
+                  (plugins, NewValue, _OldValue) ->
+                       NewValue;
+                  ({plugins, _}, NewValue, _OldValue) ->
+                       NewValue;
+                  (profiles, NewValue, OldValue) ->
+                       dict:to_list(merge_opts(dict:from_list(NewValue), dict:from_list(OldValue)));
+                  (_Key, NewValue, OldValue) when is_list(NewValue) ->
+                       case io_lib:printable_list(NewValue) of
+                           true when NewValue =:= [] ->
+                               case io_lib:printable_list(OldValue) of
+                                   true ->
+                                       NewValue;
+                                   false ->
+                                       OldValue
+                               end;
+                           true ->
+                               NewValue;
+                           false ->
+                               rebar_utils:tup_umerge(rebar_utils:tup_sort(NewValue)
+                                                     ,rebar_utils:tup_sort(OldValue))
+                       end;
+                  (_Key, NewValue, _OldValue) ->
+                       NewValue
+               end, NewOpts, OldOpts).

src/rebar_app_utils.erl

@@ -158,25 +158,27 @@ pkg_to_app(Parent, DepsDir, AppName, PkgName, PkgVsn, IsLock, State) ->
 dep_to_app(Parent, DepsDir, Name, Vsn, Source, IsLock, State) ->
     CheckoutsDir = ec_cnv:to_list(rebar_dir:checkouts_dir(State, Name)),
     BaseDir = rebar_state:get(State, base_dir, []),
-    {ok, App1} = case rebar_app_info:discover(CheckoutsDir) of
-                    {ok, App} ->
-                        {ok, rebar_app_info:is_checkout(App, true)};
-                    not_found ->
-                        Dir = ec_cnv:to_list(filename:join(DepsDir, Name)),
-                        case rebar_app_info:discover(Dir) of
-                            {ok, App} ->
-                                {ok, rebar_app_info:parent(App, Parent)};
-                            not_found ->
-                                rebar_app_info:new(Parent, Name, Vsn, Dir, [])
-                        end
-                end,
-    C = rebar_config:consult(rebar_app_info:dir(App1)),
-    S = rebar_state:new(rebar_state:new(), C, App1),
+    {ok, AppInfo} = case rebar_app_info:discover(CheckoutsDir) of
+                        {ok, App} ->
+                            {ok, rebar_app_info:is_checkout(App, true)};
+                        not_found ->
+                            Dir = ec_cnv:to_list(filename:join(DepsDir, Name)),
+                            case rebar_app_info:discover(Dir) of
+                                {ok, App} ->
+                                    {ok, rebar_app_info:parent(App, Parent)};
+                                not_found ->
+                                    rebar_app_info:new(Parent, Name, Vsn, Dir, [])
+                            end
+                    end,
+    C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
+    AppInfo0 = rebar_app_info:update_opts(AppInfo, rebar_app_info:opts(AppInfo), C),
+    AppInfo1 = rebar_app_info:apply_overrides(AppInfo0, Name),
     Overrides = rebar_state:get(State, overrides, []),
     ParentOverrides = rebar_state:overrides(State),
-    S1 = rebar_state:set(rebar_state:overrides(S, ParentOverrides++Overrides), base_dir, BaseDir),
-    App2 = rebar_app_info:state(App1, S1),
-    rebar_app_info:is_lock(rebar_app_info:source(App2, Source), IsLock).
+    S1 = rebar_state:set(rebar_state:overrides(State, ParentOverrides++Overrides), base_dir, BaseDir),
+    %AppInfo2 = rebar_app_info:state(AppInfo1, S1),
+    AppInfo3 = rebar_app_info:opts(AppInfo1, rebar_state:opts(S1)),
+    rebar_app_info:is_lock(rebar_app_info:source(AppInfo3, Source), IsLock).
 
 format_error({missing_package, Package}) ->
     io_lib:format("Package not found in registry: ~s", [Package]);

src/rebar_dir.erl

@@ -129,34 +129,34 @@ do_make_relative_path(Source, Target) ->
     Base = lists:duplicate(max(length(Target) - 1, 0), ".."),
     filename:join(Base ++ Source).
 
--spec src_dirs(rebar_state:t()) -> list(file:filename_all()).
+-spec src_dirs(rebar_app_info:t()) -> list(file:filename_all()).
 src_dirs(State) -> src_dirs(State, []).
 
--spec src_dirs(rebar_state:t(), list(file:filename_all())) -> list(file:filename_all()).
-src_dirs(State, Default) ->
-    ErlOpts = rebar_utils:erl_opts(State),
+-spec src_dirs(rebar_app_info:t(), list(file:filename_all())) -> list(file:filename_all()).
+src_dirs(AppInfo, Default) ->
+    ErlOpts = rebar_utils:erl_opts(AppInfo),
     Vs = proplists:get_all_values(src_dirs, ErlOpts),
-    case lists:append([rebar_state:get(State, src_dirs, []) | Vs]) of
+    case lists:append([rebar_utils:get(AppInfo, src_dirs, []) | Vs]) of
         []   -> Default;
         Dirs -> Dirs
     end.
 
--spec extra_src_dirs(rebar_state:t()) -> list(file:filename_all()).
-extra_src_dirs(State) -> extra_src_dirs(State, []).
+-spec extra_src_dirs(rebar_app_info:t()) -> list(file:filename_all()).
+extra_src_dirs(AppInfo) -> extra_src_dirs(AppInfo, []).
 
--spec extra_src_dirs(rebar_state:t(), list(file:filename_all())) -> list(file:filename_all()).
-extra_src_dirs(State, Default) ->
-    ErlOpts = rebar_utils:erl_opts(State),
+-spec extra_src_dirs(rebar_app_info:t(), list(file:filename_all())) -> list(file:filename_all()).
+extra_src_dirs(AppInfo, Default) ->
+    ErlOpts = rebar_utils:erl_opts(AppInfo),
     Vs = proplists:get_all_values(extra_src_dirs, ErlOpts),
-    case lists:append([rebar_state:get(State, extra_src_dirs, []) | Vs]) of
+    case lists:append([rebar_utils:get(AppInfo, extra_src_dirs, []) | Vs]) of
         []   -> Default;
         Dirs -> Dirs
     end.
 
--spec all_src_dirs(rebar_state:t()) -> list(file:filename_all()).
-all_src_dirs(State) -> all_src_dirs(State, [], []).
+-spec all_src_dirs(rebar_app_info:t()) -> list(file:filename_all()).
+all_src_dirs(AppInfo) -> all_src_dirs(AppInfo, [], []).
 
--spec all_src_dirs(rebar_state:t(), list(file:filename_all()), list(file:filename_all())) ->
+-spec all_src_dirs(rebar_app_info:t(), list(file:filename_all()), list(file:filename_all())) ->
     list(file:filename_all()).
-all_src_dirs(State, SrcDefault, ExtraDefault) ->
-    src_dirs(State, SrcDefault) ++ extra_src_dirs(State, ExtraDefault).
+all_src_dirs(AppInfo, SrcDefault, ExtraDefault) ->
+    src_dirs(AppInfo, SrcDefault) ++ extra_src_dirs(AppInfo, ExtraDefault).

src/rebar_erlc_compiler.erl

@@ -26,7 +26,7 @@
 %% -------------------------------------------------------------------
 -module(rebar_erlc_compiler).
 
--export([compile/2,
+-export([compile/1,
          compile/3,
          clean/2]).
 
@@ -80,31 +80,32 @@
 %%                           'old_inets'}]}.
 %%
 
--spec compile(rebar_state:t(), file:name()) -> 'ok'.
-compile(Config, Dir) ->
-    compile(Config, Dir, filename:join([Dir, "ebin"])).
+-spec compile(rebar_app_info:t()) -> 'ok'.
+compile(AppInfo) ->
+    Dir = ec_cnv:to_list(rebar_app_info:out_dir(AppInfo)),
+    compile(rebar_app_info:opts(AppInfo), Dir, filename:join([Dir, "ebin"])).
 
--spec compile(rebar_state:t(), file:name(), file:name()) -> 'ok'.
-compile(Config, Dir, OutDir) ->
-    rebar_base_compiler:run(Config,
-                            check_files(rebar_state:get(
-                                          Config, xrl_first_files, [])),
+-spec compile(rebar_app_info:t(), file:name(), file:name()) -> 'ok'.
+compile(AppInfo, Dir, OutDir) ->
+    rebar_base_compiler:run(AppInfo,
+                            check_files(rebar_utils:get(
+                                          AppInfo, xrl_first_files, [])),
                             filename:join(Dir, "src"), ".xrl", filename:join(Dir, "src"), ".erl",
                             fun compile_xrl/3),
-    rebar_base_compiler:run(Config,
-                            check_files(rebar_state:get(
-                                          Config, yrl_first_files, [])),
+    rebar_base_compiler:run(AppInfo,
+                            check_files(rebar_utils:get(
+                                          AppInfo, yrl_first_files, [])),
                             filename:join(Dir, "src"), ".yrl", filename:join(Dir, "src"), ".erl",
                             fun compile_yrl/3),
-    rebar_base_compiler:run(Config,
-                            check_files(rebar_state:get(
-                                          Config, mib_first_files, [])),
+    rebar_base_compiler:run(AppInfo,
+                            check_files(rebar_utils:get(
+                                          AppInfo, mib_first_files, [])),
                             filename:join(Dir, "mibs"), ".mib", filename:join([Dir, "priv", "mibs"]), ".bin",
                             fun compile_mib/3),
-    doterl_compile(Config, Dir, OutDir).
+    doterl_compile(AppInfo, Dir, OutDir).
 
--spec clean(rebar_state:t(), file:filename()) -> 'ok'.
-clean(_Config, AppDir) ->
+-spec clean(rebar_app_info:t(), file:filename()) -> 'ok'.
+clean(_AppInfo, AppDir) ->
     MibFiles = rebar_utils:find_files(filename:join(AppDir, "mibs"), ?RE_PREFIX".*\\.mib\$"),
     MIBs = [filename:rootname(filename:basename(MIB)) || MIB <- MibFiles],
     rebar_file_utils:delete_each(
@@ -133,17 +134,17 @@ clean(_Config, AppDir) ->
 %% Internal functions
 %% ===================================================================
 
--spec doterl_compile(rebar_state:t(), file:filename(), file:filename()) -> ok.
+-spec doterl_compile(rebar_app_info:t(), file:filename(), file:filename()) -> ok.
 doterl_compile(State, Dir, ODir) ->
     ErlOpts = rebar_utils:erl_opts(State),
     doterl_compile(State, Dir, ODir, [], ErlOpts).
 
-doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
+doterl_compile(AppInfo, Dir, OutDir, MoreSources, ErlOpts) ->
     ?DEBUG("erl_opts ~p", [ErlOpts]),
     %% Support the src_dirs option allowing multiple directories to
     %% contain erlang source. This might be used, for example, should
     %% eunit tests be separated from the core application source.
-    SrcDirs = [filename:join(Dir, X) || X <- rebar_dir:all_src_dirs(Config, ["src"], [])],
+    SrcDirs = [filename:join(Dir, X) || X <- rebar_dir:all_src_dirs(AppInfo, ["src"], [])],
     AllErlFiles = gather_src(SrcDirs, []) ++ MoreSources,
 
     %% Make sure that ebin/ exists and is on the path
@@ -155,7 +156,7 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
     G = init_erlcinfo(proplists:get_all_values(i, ErlOpts), AllErlFiles, Dir, OutDir),
 
     NeededErlFiles = needed_files(G, ErlOpts, Dir, OutDir1, AllErlFiles),
-    {ErlFirstFiles, ErlOptsFirst} = erl_first_files(Config, ErlOpts, Dir, NeededErlFiles),
+    {ErlFirstFiles, ErlOptsFirst} = erl_first_files(AppInfo, ErlOpts, Dir, NeededErlFiles),
     {DepErls, OtherErls} = lists:partition(
                              fun(Source) -> digraph:in_degree(G, Source) > 0 end,
                              [File || File <- NeededErlFiles, not lists:member(File, ErlFirstFiles)]),
@@ -165,7 +166,7 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
     ?DEBUG("Files to compile first: ~p", [FirstErls]),
     try
         rebar_base_compiler:run(
-          Config, FirstErls, OtherErls,
+          AppInfo, FirstErls, OtherErls,
           fun(S, C) ->
                   ErlOpts1 = case lists:member(S, ErlFirstFiles) of
                                  true -> ErlOptsFirst;
@@ -182,8 +183,8 @@ doterl_compile(Config, Dir, OutDir, MoreSources, ErlOpts) ->
 %% Get files which need to be compiled first, i.e. those specified in erl_first_files
 %% and parse_transform options.  Also produce specific erl_opts for these first
 %% files, so that yet to be compiled parse transformations are excluded from it.
-erl_first_files(Config, ErlOpts, Dir, NeededErlFiles) ->
-    ErlFirstFilesConf = rebar_state:get(Config, erl_first_files, []),
+erl_first_files(AppInfo, ErlOpts, Dir, NeededErlFiles) ->
+    ErlFirstFilesConf = rebar_utils:get(AppInfo, erl_first_files, []),
     NeededSrcDirs = lists:usort(lists:map(fun filename:dirname/1, NeededErlFiles)),
     %% NOTE: order of files here is important!
     ErlFirstFiles =
@@ -402,9 +403,9 @@ expand_file_names(Files, Dirs) ->
       end, Files).
 
 
--spec internal_erl_compile(rebar_state:t(), file:filename(), file:filename(),
+-spec internal_erl_compile(rebar_app_info:t(), file:filename(), file:filename(),
     file:filename(), list()) -> ok | {ok, any()} | {error, any(), any()}.
-internal_erl_compile(Config, Dir, Module, OutDir, ErlOpts) ->
+internal_erl_compile(AppInfo, Dir, Module, OutDir, ErlOpts) ->
     Target = target_base(OutDir, Module) ++ ".beam",
     ok = filelib:ensure_dir(Target),
     Opts = [{outdir, filename:dirname(Target)}] ++ ErlOpts ++
@@ -413,23 +414,23 @@ internal_erl_compile(Config, Dir, Module, OutDir, ErlOpts) ->
         {ok, _Mod} ->
             ok;
         {ok, _Mod, Ws} ->
-            rebar_base_compiler:ok_tuple(Config, Module, Ws);
+            rebar_base_compiler:ok_tuple(AppInfo, Module, Ws);
         {error, Es, Ws} ->
-            rebar_base_compiler:error_tuple(Config, Module, Es, Ws, Opts)
+            rebar_base_compiler:error_tuple(AppInfo, Module, Es, Ws, Opts)
     end.
 
 target_base(OutDir, Source) ->
     filename:join(OutDir, filename:basename(Source, ".erl")).
 
 -spec compile_mib(file:filename(), file:filename(),
-                  rebar_state:t()) -> 'ok'.
-compile_mib(Source, Target, Config) ->
-    Dir = rebar_state:dir(Config),
+                  rebar_app_info:t()) -> 'ok'.
+compile_mib(Source, Target, AppInfo) ->
+    Dir = filename:dirname(Target),
     ok = filelib:ensure_dir(Target),
     ok = filelib:ensure_dir(filename:join([Dir, "include", "dummy.hrl"])),
-    Opts = [{outdir, filename:join([Dir, "priv", "mibs"])}
-           ,{i, [filename:join([Dir, "priv", "mibs"])]}] ++
-        rebar_state:get(Config, mib_opts, []),
+    Opts = [{outdir, Dir}
+           ,{i, [Dir]}] ++
+        rebar_utils:get(AppInfo, mib_opts, []),
 
     case snmpc:compile(Source, Opts) of
         {ok, _} ->
@@ -450,21 +451,21 @@ compile_mib(Source, Target, Config) ->
     end.
 
 -spec compile_xrl(file:filename(), file:filename(),
-                  rebar_state:t()) -> 'ok'.
-compile_xrl(Source, Target, Config) ->
-    Opts = [{scannerfile, Target} | rebar_state:get(Config, xrl_opts, [])],
-    compile_xrl_yrl(Config, Source, Target, Opts, leex).
+                  rebar_app_info:t()) -> 'ok'.
+compile_xrl(Source, Target, AppInfo) ->
+    Opts = [{scannerfile, Target} | rebar_utils:get(AppInfo, xrl_opts, [])],
+    compile_xrl_yrl(AppInfo, Source, Target, Opts, leex).
 
 -spec compile_yrl(file:filename(), file:filename(),
-                  rebar_state:t()) -> 'ok'.
-compile_yrl(Source, Target, Config) ->
-    Opts = [{parserfile, Target} | rebar_state:get(Config, yrl_opts, [])],
-    compile_xrl_yrl(Config, Source, Target, Opts, yecc).
+                  rebar_app_info:t()) -> 'ok'.
+compile_yrl(Source, Target, AppInfo) ->
+    Opts = [{parserfile, Target} | rebar_utils:get(AppInfo, yrl_opts, [])],
+    compile_xrl_yrl(AppInfo, Source, Target, Opts, yecc).
 
--spec compile_xrl_yrl(rebar_state:t(), file:filename(),
+-spec compile_xrl_yrl(rebar_app_info:t(), file:filename(),
                       file:filename(), list(), module()) -> 'ok'.
-compile_xrl_yrl(Config, Source, Target, Opts, Mod) ->
-    Dir = rebar_state:dir(Config),
+compile_xrl_yrl(AppInfo, Source, Target, Opts, Mod) ->
+    Dir = filename:dirname(Target),
     Opts1 = [{includefile, filename:join(Dir, I)} || {includefile, I} <- Opts,
                                                      filename:pathtype(I) =:= relative],
     case needs_compile(Source, Target) of
@@ -473,9 +474,9 @@ compile_xrl_yrl(Config, Source, Target, Opts, Mod) ->
                 {ok, _} ->
                     ok;
                 {ok, _Mod, Ws} ->
-                    rebar_base_compiler:ok_tuple(Config, Source, Ws);
+                    rebar_base_compiler:ok_tuple(AppInfo, Source, Ws);
                 {error, Es, Ws} ->
-                    rebar_base_compiler:error_tuple(Config, Source,
+                    rebar_base_compiler:error_tuple(AppInfo, Source,
                                                     Es, Ws, Opts1)
             end;
         false ->

src/rebar_hooks.erl

@@ -1,30 +1,34 @@
 -module(rebar_hooks).
 
 -export([run_all_hooks/5
+        ,run_all_hooks/6
         ,format_error/1]).
 
 -include("rebar.hrl").
 -include_lib("providers/include/providers.hrl").
 
+run_all_hooks(Dir, Type, Command, Providers, State) ->
+    run_all_hooks(Dir, Type, Command, Providers,  element(2,rebar_app_info:new(noen)), State).
+
 -spec run_all_hooks(file:filename_all(), pre | post,
                    atom() | {atom(), atom()} | string(),
-                   [providers:t()], rebar_state:t()) -> ok.
-run_all_hooks(Dir, Type, Command, Providers, State) ->
-    run_provider_hooks(Dir, Type, Command, Providers, State),
-    run_hooks(Dir, Type, Command, State).
+                   [providers:t()], rebar_app_info:t(), rebar_state:t()) -> ok.
+run_all_hooks(Dir, Type, Command, Providers, AppInfo, State) ->
+    run_provider_hooks(Dir, Type, Command, Providers, AppInfo, State),
+    run_hooks(Dir, Type, Command, AppInfo, State).
 
-run_provider_hooks(Dir, Type, Command, Providers, State) ->
-    case rebar_state:get(State, provider_hooks, []) of
+run_provider_hooks(Dir, Type, Command, Providers, AppInfo, State) ->
+    case rebar_app_info:get(AppInfo, provider_hooks, [])++rebar_state:get(State, provider_hooks, []) of
         [] ->
             ok;
         AllHooks ->
             TypeHooks = proplists:get_value(Type, AllHooks, []),
-            run_provider_hooks(Dir, Type, Command, Providers, TypeHooks, State)
+            run_provider_hooks(Dir, Type, Command, Providers, TypeHooks, AppInfo, State)
     end.
 
-run_provider_hooks(_Dir, _Type, _Command, _Providers, [], _State) ->
+run_provider_hooks(_Dir, _Type, _Command, _Providers, [], _AppInfo, _State) ->
     ok;
-run_provider_hooks(Dir, Type, Command, Providers, TypeHooks, State) ->
+run_provider_hooks(Dir, Type, Command, Providers, TypeHooks, _AppInfo, State) ->
     PluginDepsPaths = rebar_state:code_paths(State, all_plugin_deps),
     code:add_pathsa(PluginDepsPaths),
     Providers1 = rebar_state:providers(State),
@@ -67,16 +71,16 @@ format_error({bad_provider, Type, Command, Name}) ->
 %% ERL                          = ERLANG_ROOT_DIR/bin/erl
 %% ERLC                         = ERLANG_ROOT_DIR/bin/erl
 %%
-run_hooks(Dir, pre, Command, State) ->
-    run_hooks(Dir, pre_hooks, Command, State);
-run_hooks(Dir, post, Command, State) ->
-    run_hooks(Dir, post_hooks, Command, State);
-run_hooks(Dir, Type, Command, State) ->
-    case rebar_state:get(State, Type, []) of
+run_hooks(Dir, pre, Command, AppInfo, State) ->
+    run_hooks(Dir, pre_hooks, Command, AppInfo, State);
+run_hooks(Dir, post, Command, AppInfo, State) ->
+    run_hooks(Dir, post_hooks, Command, AppInfo, State);
+run_hooks(Dir, Type, Command, AppInfo, State) ->
+    case rebar_app_info:get(AppInfo, Type, []) of
         [] ->
             ok;
         Hooks ->
-            Env = create_env(State),
+            Env = create_env(State, AppInfo),
             lists:foreach(fun({_, C, _}=Hook) when C =:= Command ->
                                   apply_hook(Dir, Env, Hook);
                              ({C, _}=Hook) when C =:= Command ->
@@ -97,8 +101,9 @@ apply_hook(Dir, Env, {Command, Hook}) ->
     Msg = lists:flatten(io_lib:format("Hook for ~p failed!~n", [Command])),
     rebar_utils:sh(Hook, [use_stdout, {cd, Dir}, {env, Env}, {abort_on_error, Msg}]).
 
-create_env(State) ->
-    BaseDir = rebar_state:dir(State),
+create_env(State, AppInfo) ->
+    Opts = rebar_app_info:opts(AppInfo),
+    BaseDir = rebar_dir:base_dir(State),
     [
      {"REBAR_DEPS_DIR",          filename:absname(rebar_dir:deps_dir(State))},
      {"REBAR_BUILD_DIR",         filename:absname(rebar_dir:base_dir(State))},
@@ -109,7 +114,7 @@ create_env(State) ->
      {"REBAR_GLOBAL_CACHE_DIR",  filename:absname(rebar_dir:global_cache_dir(State))},
      {"REBAR_TEMPLATE_DIR",      filename:absname(rebar_dir:template_dir(State))},
      {"REBAR_APP_DIRS",          join_dirs(BaseDir, rebar_dir:lib_dirs(State))},
-     {"REBAR_SRC_DIRS",          join_dirs(BaseDir, rebar_dir:all_src_dirs(State))},
+     {"REBAR_SRC_DIRS",          join_dirs(BaseDir, rebar_dir:all_src_dirs(Opts))},
      {"ERLANG_ERTS_VER",         erlang:system_info(version)},
      {"ERLANG_ROOT_DIR",         code:root_dir()},
      {"ERLANG_LIB_DIR_erl_interface", code:lib_dir(erl_interface)},

src/rebar_otp_app.erl

@@ -106,7 +106,7 @@ preprocess(State, AppInfo, AppSrcFile) ->
             %% substitute. Note that we include the list of modules available in
             %% ebin/ and update the app data accordingly.
             OutDir = rebar_app_info:out_dir(AppInfo),
-            AppVars = load_app_vars(State) ++ [{modules, ebin_modules(State, AppInfo, OutDir)}],
+            AppVars = load_app_vars(State) ++ [{modules, ebin_modules(AppInfo, OutDir)}],
             A1 = apply_app_vars(AppVars, AppData),
 
             %% AppSrcFile may contain instructions for generating a vsn number
@@ -158,21 +158,21 @@ validate_name(AppName, File) ->
             ?PRV_ERROR({invalid_name, File, AppName})
     end.
 
-ebin_modules(State, App, Dir) ->
+ebin_modules(AppInfo, Dir) ->
     Beams = lists:sort(rebar_utils:beams(filename:join(Dir, "ebin"))),
-    ExtraDirs = extra_dirs(State),
-    F = fun(Beam) -> not in_extra_dir(App, Beam, ExtraDirs) end,
+    ExtraDirs = extra_dirs(AppInfo),
+    F = fun(Beam) -> not in_extra_dir(AppInfo, Beam, ExtraDirs) end,
     Filtered = lists:filter(F, Beams),
     [rebar_utils:beam_to_mod(N) || N <- Filtered].
 
 extra_dirs(State) ->
-    Extras = rebar_dir:extra_src_dirs(State),
-    SrcDirs = rebar_dir:src_dirs(State, ["src"]),
+    Extras = rebar_dir:extra_src_dirs(rebar_app_info:opts(State)),
+    SrcDirs = rebar_dir:src_dirs(rebar_app_info:opts(State), ["src"]),
     %% remove any dirs that are defined in `src_dirs` from `extra_src_dirs`
     Extras -- SrcDirs.
 
-in_extra_dir(App, Beam, Dirs) ->
-    lists:any(fun(Dir) -> lists:prefix(filename:join([rebar_app_info:out_dir(App), Dir]),
+in_extra_dir(AppInfo, Beam, Dirs) ->
+    lists:any(fun(Dir) -> lists:prefix(filename:join([rebar_app_info:out_dir(AppInfo), Dir]),
                                        beam_src(Beam)) end,
               Dirs).
 

src/rebar_plugins.erl

@@ -4,7 +4,7 @@
 -module(rebar_plugins).
 
 -export([project_apps_install/1
-        ,install/1
+        ,install/2
         ,handle_plugins/3
         ,handle_plugins/4]).
 
@@ -23,20 +23,19 @@ project_apps_install(State) ->
                         Plugins = rebar_state:get(State, {plugins, Profile}, []),
                         StateAcc1 = handle_plugins(Profile, Plugins, StateAcc),
 
-                        lists:foldl(fun(App, StateAcc2) ->
-                                            AppDir = rebar_app_info:dir(App),
-                                            C = rebar_config:consult(AppDir),
-                                            S = rebar_state:new(rebar_state:new(), C, AppDir),
-                                            Plugins2 = rebar_state:get(S, {plugins, Profile}, []),
+                        lists:foldl(fun(AppInfo, StateAcc2) ->
+                                            C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
+                                            AppInfo0 = rebar_app_info:update_opts(AppInfo, rebar_app_info:opts(AppInfo), C),
+                                            Plugins2 = rebar_state:get(AppInfo0, {plugins, Profile}, []),
                                             handle_plugins(Profile, Plugins2, StateAcc2)
                                     end, StateAcc1, ProjectApps)
                 end, State, Profiles).
 
--spec install(rebar_state:t()) -> rebar_state:t().
-install(State) ->
+-spec install(rebar_state:t(), rebar_app_info:t()) -> rebar_state:t().
+install(State, AppInfo) ->
     Profiles = rebar_state:current_profiles(State),
     lists:foldl(fun(Profile, StateAcc) ->
-                        Plugins = rebar_state:get(State, {plugins, Profile}, []),
+                        Plugins = rebar_app_info:get(AppInfo, {plugins, Profile}, []),
                         handle_plugins(Profile, Plugins, StateAcc)
                 end, State, Profiles).
 
@@ -92,10 +91,10 @@ handle_plugin(Profile, Plugin, State, Upgrade) ->
 
 build_plugin(AppInfo, Apps, State) ->
     Providers = rebar_state:providers(State),
-    Providers1 = rebar_state:providers(rebar_app_info:state(AppInfo)),
+    %Providers1 = rebar_state:providers(rebar_app_info:state(AppInfo)),
     S = rebar_state:all_deps(rebar_app_info:state_or_new(State, AppInfo), Apps),
     S1 = rebar_state:set(S, deps_dir, ?DEFAULT_PLUGINS_DIR),
-    rebar_prv_compile:compile(S1, Providers++Providers1, AppInfo).
+    rebar_prv_compile:compile(S1, Providers, AppInfo).
 
 plugin_providers({Plugin, _, _, _}) when is_atom(Plugin) ->
     validate_plugin(Plugin);

src/rebar_prv_clean.erl

@@ -50,9 +50,9 @@ do(State) ->
     clean_apps(EmptyState, Providers, DepApps),
 
     Cwd = rebar_dir:get_cwd(),
-    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, State),
+    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State),
     clean_apps(State, Providers, ProjectApps),
-    rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State),
+    rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State),
 
     {ok, State}.
 
@@ -70,9 +70,9 @@ clean_apps(State, Providers, Apps) ->
                           S = rebar_app_info:state_or_new(State, AppInfo),
 
                           ?INFO("Cleaning out ~s...", [rebar_app_info:name(AppInfo)]),
-                          rebar_hooks:run_all_hooks(AppDir, pre, ?PROVIDER, Providers, S),
+                          rebar_hooks:run_all_hooks(AppDir, pre, ?PROVIDER, Providers, AppInfo, S),
                           rebar_erlc_compiler:clean(State, rebar_app_info:out_dir(AppInfo)),
-                          rebar_hooks:run_all_hooks(AppDir, post, ?PROVIDER, Providers, S)
+                          rebar_hooks:run_all_hooks(AppDir, post, ?PROVIDER, Providers, AppInfo, S)
                   end, Apps).
 
 handle_args(State) ->

src/rebar_prv_common_test.erl

@@ -43,12 +43,12 @@ do(State) ->
     %% Run ct provider prehooks
     Providers = rebar_state:providers(State),
     Cwd = rebar_dir:get_cwd(),
-    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, State),
+    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State),
 
     try run_test(State) of
         {ok, State1} = Result ->
             %% Run ct provider posthooks
-            rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, State1),
+            rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State1),
             rebar_utils:cleanup_code_path(rebar_state:code_paths(State, default)),
             Result;
         ?PRV_ERROR(_) = Error ->
@@ -307,7 +307,7 @@ copy(State, Dir) ->
 
 compile_dir(State, Dir) ->
     NewState = replace_src_dirs(State, [filename:absname(Dir)]),
-    ok = rebar_erlc_compiler:compile(NewState, rebar_dir:base_dir(State), Dir),
+    ok = rebar_erlc_compiler:compile(rebar_state:opts(NewState), rebar_dir:base_dir(State), Dir),
     ok = maybe_cover_compile(State, Dir),
     Dir.
 

src/rebar_prv_compile.erl

@@ -52,7 +52,7 @@ do(State) ->
     {ok, ProjectApps1} = rebar_digraph:compile_order(ProjectApps),
 
     %% Run top level hooks *before* project apps compiled but *after* deps are
-    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, State),
+    rebar_hooks:run_all_hooks(Cwd, pre, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State),
 
     ProjectApps2 = build_apps(State, Providers, ProjectApps1),
     State2 = rebar_state:project_apps(State, ProjectApps2),
@@ -60,7 +60,7 @@ do(State) ->
     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, State2),
+    rebar_hooks:run_all_hooks(Cwd, post, ?PROVIDER, Providers, element(2,rebar_app_info:new(noen)), State2),
     has_all_artifacts(State3),
 
     rebar_utils:cleanup_code_path(rebar_state:code_paths(State3, default)
@@ -80,7 +80,7 @@ build_apps(State, Providers, Apps) ->
 build_app(State, Providers, AppInfo) ->
     AppDir = rebar_app_info:dir(AppInfo),
     OutDir = rebar_app_info:out_dir(AppInfo),
-    copy_app_dirs(State, AppDir, OutDir),
+    copy_app_dirs(AppInfo, AppDir, OutDir),
 
     S = rebar_app_info:state_or_new(State, AppInfo),
     S1 = rebar_state:all_deps(S, rebar_state:all_deps(State)),
@@ -89,12 +89,12 @@ build_app(State, Providers, AppInfo) ->
 compile(State, Providers, AppInfo) ->
     ?INFO("Compiling ~s", [rebar_app_info:name(AppInfo)]),
     AppDir = rebar_app_info:dir(AppInfo),
-    rebar_hooks:run_all_hooks(AppDir, pre, ?PROVIDER,  Providers, State),
+    rebar_hooks:run_all_hooks(AppDir, pre, ?PROVIDER,  Providers, AppInfo, State),
 
-    rebar_erlc_compiler:compile(State, ec_cnv:to_list(rebar_app_info:out_dir(AppInfo))),
+    rebar_erlc_compiler:compile(AppInfo),
     case rebar_otp_app:compile(State, AppInfo) of
         {ok, AppInfo1} ->
-            rebar_hooks:run_all_hooks(AppDir, post, ?PROVIDER, Providers, State),
+            rebar_hooks:run_all_hooks(AppDir, post, ?PROVIDER, Providers, AppInfo, State),
             has_all_artifacts(State),
             AppInfo1;
         Error ->
@@ -113,7 +113,7 @@ has_all_artifacts(State) ->
             true
     end.
 
-copy_app_dirs(State, OldAppDir, AppDir) ->
+copy_app_dirs(AppInfo, OldAppDir, AppDir) ->
     case ec_cnv:to_binary(filename:absname(OldAppDir)) =/=
         ec_cnv:to_binary(filename:absname(AppDir)) of
         true ->
@@ -142,7 +142,7 @@ copy_app_dirs(State, OldAppDir, AppDir) ->
             end,
 
             %% link to src_dirs to be adjacent to ebin is needed for R15 use of cover/xref
-            SrcDirs = rebar_dir:all_src_dirs(State, ["src"], []),
+            SrcDirs = rebar_dir:all_src_dirs(rebar_app_info:opts(AppInfo), ["src"], []),
             [symlink_or_copy(OldAppDir, AppDir, Dir) || Dir <- ["priv", "include"] ++ SrcDirs];
         false ->
             ok

src/rebar_prv_install_deps.erl

@@ -254,28 +254,29 @@ handle_dep(State, Profile, DepsDir, AppInfo, Locks, Level) ->
     Profiles = rebar_state:current_profiles(State),
     Name = rebar_app_info:name(AppInfo),
 
-    %% Deps may be under a sub project app, find it and use its state if so
-    S = rebar_app_info:state(AppInfo),
     C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
-    S1 = rebar_state:new(S, C, AppInfo),
-    S2 = rebar_state:apply_overrides(S1, Name),
+    AppInfo0 = rebar_app_info:update_opts(AppInfo, rebar_app_info:opts(AppInfo), C),
+    AppInfo1 = rebar_app_info:apply_overrides(AppInfo0, Name),
 
-    S3 = rebar_state:apply_profiles(S2, Profiles),
-    Plugins = rebar_state:get(S3, plugins, []),
-    S4 = rebar_state:set(S3, {plugins, Profile}, Plugins),
+    AppInfo2 = rebar_app_info:apply_profiles(AppInfo1, Profiles),
+    Plugins = rebar_app_info:get(AppInfo2, plugins, []),
+    AppInfo3 = rebar_app_info:set(AppInfo2, {plugins, Profile}, Plugins),
 
-    rebar_utils:check_min_otp_version(rebar_state:get(S4, minimum_otp_vsn, undefined)),
-    rebar_utils:check_blacklisted_otp_versions(rebar_state:get(S4, blacklisted_otp_vsns, [])),
+    rebar_utils:check_min_otp_version(rebar_app_info:get(AppInfo3, minimum_otp_vsn, undefined)),
+    rebar_utils:check_blacklisted_otp_versions(rebar_app_info:get(AppInfo3, blacklisted_otp_vsns, [])),
 
     %% Dep may have plugins to install. Find and install here.
-    S5 = rebar_plugins:install(S4),
-    AppInfo1 = rebar_app_info:state(AppInfo, S5),
+    _S = rebar_plugins:install(State, AppInfo3),
+    %% TODO: Plugin Providers??
+
+    %AppInfo1 = rebar_app_info:state(AppInfo, S5),
+    %AppInfo2 = rebar_app_info:opts(AppInfo1, rebar_state:opts(S5)),
 
     %% Upgrade lock level to be the level the dep will have in this dep tree
-    Deps = rebar_state:get(S5, {deps, default}, []),
-    AppInfo2 = rebar_app_info:deps(AppInfo1, rebar_state:deps_names(Deps)),
-    Deps1 = rebar_app_utils:parse_deps(Name, DepsDir, Deps, S5, Locks, Level+1),
-    {AppInfo2, Deps1, State}.
+    Deps = rebar_app_info:get(AppInfo3, {deps, default}, []),
+    AppInfo4 = rebar_app_info:deps(AppInfo3, rebar_state:deps_names(Deps)),
+    Deps1 = rebar_app_utils:parse_deps(Name, DepsDir, Deps, State, Locks, Level+1),
+    {AppInfo4, Deps1, State}.
 
 -spec maybe_fetch(rebar_app_info:t(), atom(), boolean(),
                   sets:set(binary()), rebar_state:t()) -> {boolean(), rebar_app_info:t()}.
@@ -420,4 +421,4 @@ warn_skip_deps(AppInfo, State) ->
 not_needs_compile(App) ->
     not(rebar_app_info:is_checkout(App))
         andalso rebar_app_info:valid(App)
-          andalso rebar_state:has_all_artifacts(rebar_app_info:state(App)) =:= true.
+          andalso rebar_app_info:has_all_artifacts(App) =:= true.

src/rebar_utils.erl

@@ -26,7 +26,10 @@
 %% -------------------------------------------------------------------
 -module(rebar_utils).
 
--export([sort_deps/1,
+-export([get/2,
+         get/3,
+         set/3,
+         sort_deps/1,
          droplast/1,
          filtermap/2,
          is_arch/1,
@@ -80,6 +83,21 @@
 %% Public API
 %% ====================================================================
 
+get(Opts, Key) ->
+    {ok, Value} = dict:find(Key, Opts),
+    Value.
+
+get(Opts, Key, Default) ->
+    case dict:find(Key, Opts) of
+        {ok, Value} ->
+            Value;
+        error ->
+            Default
+    end.
+
+set(Opts, Key, Value) ->
+    dict:store(Key, Value, Opts).
+
 sort_deps(Deps) ->
     %% We need a sort stable, based on the name. So that for multiple deps on
     %% the same level with the same name, we keep the order the parents had.
@@ -219,11 +237,11 @@ deprecated(Old, New, When) ->
       [Old, Old, New, Old, When]).
 
 %% @doc Return list of erl_opts
--spec erl_opts(rebar_state:t()) -> list().
-erl_opts(Config) ->
-    RawErlOpts = filter_defines(rebar_state:get(Config, erl_opts, []), []),
+-spec erl_opts(rebar_app_info:t()) -> list().
+erl_opts(AppInfo) ->
+    RawErlOpts = filter_defines(rebar_utils:get(AppInfo, erl_opts, []), []),
     Defines = [{d, list_to_atom(D)} ||
-                  D <- rebar_state:get(Config, defines, [])],
+                  D <- rebar_utils:get(AppInfo, defines, [])],
     Opts = Defines ++ RawErlOpts,
     case proplists:is_defined(no_debug_info, Opts) of
         true ->

test/rebar_dir_SUITE.erl

@@ -28,39 +28,39 @@ end_per_testcase(_, _Config) -> ok.
 
 default_src_dirs(Config) ->
     {ok, State} = rebar_test_utils:run_and_check(Config, [], ["compile"], return),
-    
-    [] = rebar_dir:src_dirs(State),
-    ["src"] = rebar_dir:src_dirs(State, ["src"]).
+
+    [] = rebar_dir:src_dirs(rebar_state:opts(State)),
+    ["src"] = rebar_dir:src_dirs(rebar_state:opts(State), ["src"]).
 
 default_extra_src_dirs(Config) ->
     {ok, State} = rebar_test_utils:run_and_check(Config, [], ["compile"], return),
-  
-    [] = rebar_dir:extra_src_dirs(State),
-    ["src"] = rebar_dir:extra_src_dirs(State, ["src"]).
+
+    [] = rebar_dir:extra_src_dirs(rebar_state:opts(State)),
+    ["src"] = rebar_dir:extra_src_dirs(rebar_state:opts(State), ["src"]).
 
 default_all_src_dirs(Config) ->
     {ok, State} = rebar_test_utils:run_and_check(Config, [], ["compile"], return),
-  
-    [] = rebar_dir:all_src_dirs(State),
-    ["src", "test"] = rebar_dir:all_src_dirs(State, ["src"], ["test"]).
+
+    [] = rebar_dir:all_src_dirs(rebar_state:opts(State)),
+    ["src", "test"] = rebar_dir:all_src_dirs(rebar_state:opts(State), ["src"], ["test"]).
 
 src_dirs(Config) ->
     RebarConfig = [{erl_opts, [{src_dirs, ["foo", "bar", "baz"]}]}],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
-    
-    ["foo", "bar", "baz"] = rebar_dir:src_dirs(State).
+
+    ["foo", "bar", "baz"] = rebar_dir:src_dirs(rebar_state:opts(State)).
 
 extra_src_dirs(Config) ->
     RebarConfig = [{erl_opts, [{extra_src_dirs, ["foo", "bar", "baz"]}]}],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
-    
-    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(State).
+
+    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(rebar_state:opts(State)).
 
 all_src_dirs(Config) ->
     RebarConfig = [{erl_opts, [{src_dirs, ["foo", "bar"]}, {extra_src_dirs, ["baz", "qux"]}]}],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
-    
-    ["foo", "bar", "baz", "qux"] = rebar_dir:all_src_dirs(State).
+
+    ["foo", "bar", "baz", "qux"] = rebar_dir:all_src_dirs(rebar_state:opts(State)).
 
 profile_src_dirs(Config) ->
     RebarConfig = [
@@ -70,9 +70,9 @@ profile_src_dirs(Config) ->
         ]}
     ],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["as", "more", "compile"], return),
-    
+
     R = lists:sort(["foo", "bar", "baz", "qux"]),
-    R = lists:sort(rebar_dir:src_dirs(State)).
+    R = lists:sort(rebar_dir:src_dirs(rebar_state:opts(State))).
 
 profile_extra_src_dirs(Config) ->
     RebarConfig = [
@@ -82,9 +82,9 @@ profile_extra_src_dirs(Config) ->
         ]}
     ],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["as", "more", "compile"], return),
-    
+
     R = lists:sort(["foo", "bar", "baz", "qux"]),
-    R = lists:sort(rebar_dir:extra_src_dirs(State)).
+    R = lists:sort(rebar_dir:extra_src_dirs(rebar_state:opts(State))).
 
 profile_all_src_dirs(Config) ->
     RebarConfig = [
@@ -94,6 +94,6 @@ profile_all_src_dirs(Config) ->
         ]}
     ],
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["as", "more", "compile"], return),
-    
+
     R = lists:sort(["foo", "bar", "baz", "qux"]),
-    R = lists:sort(rebar_dir:all_src_dirs(State)).
+    R = lists:sort(rebar_dir:all_src_dirs(rebar_state:opts(State))).

test/rebar_src_dirs_SUITE.erl

@@ -49,7 +49,7 @@ src_dirs_at_root(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["foo", "bar", "baz"] = rebar_dir:src_dirs(State, []).
+    ["foo", "bar", "baz"] = rebar_dir:src_dirs(rebar_state:opts(State), []).
 
 extra_src_dirs_at_root(Config) ->
     AppDir = ?config(apps, Config),
@@ -62,7 +62,7 @@ extra_src_dirs_at_root(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(State, []).
+    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(rebar_state:opts(State), []).
 
 src_dirs_in_erl_opts(Config) ->
     AppDir = ?config(apps, Config),
@@ -75,7 +75,7 @@ src_dirs_in_erl_opts(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["foo", "bar", "baz"] = rebar_dir:src_dirs(State, []).
+    ["foo", "bar", "baz"] = rebar_dir:src_dirs(rebar_state:opts(State), []).
 
 extra_src_dirs_in_erl_opts(Config) ->
     AppDir = ?config(apps, Config),
@@ -88,7 +88,7 @@ extra_src_dirs_in_erl_opts(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(State, []).
+    ["foo", "bar", "baz"] = rebar_dir:extra_src_dirs(rebar_state:opts(State), []).
 
 src_dirs_at_root_and_in_erl_opts(Config) ->
     AppDir = ?config(apps, Config),
@@ -101,7 +101,7 @@ src_dirs_at_root_and_in_erl_opts(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["baz", "qux", "foo", "bar"] = rebar_dir:src_dirs(State, []).
+    ["baz", "qux", "foo", "bar"] = rebar_dir:src_dirs(rebar_state:opts(State), []).
 
 extra_src_dirs_at_root_and_in_erl_opts(Config) ->
     AppDir = ?config(apps, Config),
@@ -114,7 +114,7 @@ extra_src_dirs_at_root_and_in_erl_opts(Config) ->
 
     {ok, State} = rebar_test_utils:run_and_check(Config, RebarConfig, ["compile"], return),
 
-    ["baz", "qux", "foo", "bar"] = rebar_dir:extra_src_dirs(State, []).
+    ["baz", "qux", "foo", "bar"] = rebar_dir:extra_src_dirs(rebar_state:opts(State), []).
 
 build_basic_app(Config) ->
     AppDir = ?config(apps, Config),