generalize the "test" special dir into an {extra_src_dirs, [...]} option

like `src_dirs`, `extra_src_dirs` are directories to be copied to
the `_build` dir and compiled. unlike `src_dirs` they are not added
to the .app specification

4 files changed, 41 insertions, 49 deletions

diff --git a/src/rebar_erlc_compiler.erl b/src/rebar_erlc_compiler.erl
index 8fe03b7..366f40a 100644
--- a/src/rebar_erlc_compiler.erl
+++ b/src/rebar_erlc_compiler.erl
@@ -143,7 +143,8 @@ doterl_compile(Config, Dir, OutDir, MoreSources, 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 <- proplists:get_value(src_dirs, ErlOpts, ["src"])],
+    SrcDirs = [filename:join(Dir, X) || X <- proplists:get_value(src_dirs, ErlOpts, ["src"]) ++
+                                             proplists:get_value(extra_src_dirs, ErlOpts, [])],
     AllErlFiles = gather_src(SrcDirs, []) ++ MoreSources,
 
     %% Make sure that ebin/ exists and is on the path
diff --git a/src/rebar_otp_app.erl b/src/rebar_otp_app.erl
index 0bf27c9..e5ad1d2 100644
--- a/src/rebar_otp_app.erl
+++ b/src/rebar_otp_app.erl
@@ -100,7 +100,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(AppInfo, OutDir)}],
+            AppVars = load_app_vars(State) ++ [{modules, ebin_modules(State, AppInfo, OutDir)}],
             A1 = apply_app_vars(AppVars, AppData),
 
             %% AppSrcFile may contain instructions for generating a vsn number
@@ -152,14 +152,25 @@ validate_name(AppName, File) ->
             ?PRV_ERROR({invalid_name, File, AppName})
     end.
 
-ebin_modules(App, Dir) ->
+ebin_modules(State, App, Dir) ->
     Beams = lists:sort(rebar_utils:beams(filename:join(Dir, "ebin"))),
-    F = fun(Beam) -> not lists:prefix(filename:join([rebar_app_info:out_dir(App), "test"]),
-                                      beam_src(Beam))
-    end,
+    ExtraDirs = extra_dirs(State),
+    F = fun(Beam) -> not in_extra_dir(App, Beam, ExtraDirs) end,
     Filtered = lists:filter(F, Beams),
     [rebar_utils:beam_to_mod(N) || N <- Filtered].
 
+extra_dirs(State) ->
+    ErlOpts = rebar_utils:erl_opts(State),
+    Extras = proplists:get_value(extra_src_dirs, ErlOpts, []),
+    SrcDirs = proplists:get_value(src_dirs, ErlOpts, ["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]),
+                                       beam_src(Beam)) end,
+              Dirs).
+
 beam_src(Beam) ->
     case beam_lib:chunks(Beam, [compile_info]) of
         {ok, {_mod, Chunks}} ->
diff --git a/src/rebar_prv_compile.erl b/src/rebar_prv_compile.erl
index 1fb29bd..f70ca28 100644
--- a/src/rebar_prv_compile.erl
+++ b/src/rebar_prv_compile.erl
@@ -120,8 +120,9 @@ copy_app_dirs(State, OldAppDir, AppDir) ->
             filelib:ensure_dir(filename:join(AppDir, "dummy")),
             %% link to src_dirs to be adjacent to ebin is needed for R15 use of cover/xref
             ErlOpts = rebar_utils:erl_opts(State),
-            SrcDirs = proplists:get_value(src_dirs, ErlOpts, ["src"]),
-            [symlink_or_copy(OldAppDir, AppDir, Dir) || Dir <- ["priv", "include", "test"] ++ SrcDirs];
+            SrcDirs = proplists:get_value(src_dirs, ErlOpts, ["src"]) ++
+                      proplists:get_value(extra_src_dirs, ErlOpts, []),
+            [symlink_or_copy(OldAppDir, AppDir, Dir) || Dir <- ["priv", "include"] ++ SrcDirs];
         false ->
             ok
     end.
diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl
index 12dd5f9..8eaa926 100644
--- a/src/rebar_prv_eunit.erl
+++ b/src/rebar_prv_eunit.erl
@@ -84,7 +84,8 @@ format_error({error_running_tests, Reason}) ->
 test_state(State) ->
     ErlOpts = rebar_state:get(State, eunit_compile_opts, []),
     TestOpts = safe_define_test_macro(ErlOpts),
-    first_files(State) ++ [{erl_opts, TestOpts}].
+    TestDir = [{extra_src_dirs, ["test"]}],
+    first_files(State) ++ [{erl_opts, TestOpts ++ TestDir}].
 
 safe_define_test_macro(Opts) ->
     %% defining a compile macro twice results in an exception so
@@ -105,54 +106,38 @@ first_files(State) ->
 
 prepare_tests(State) ->
     {RawOpts, _} = rebar_state:command_parsed_args(State),
-    resolve_apps(State, RawOpts).
+    ok = maybe_cover_compile(State, RawOpts),
+    ProjectApps = project_apps(State),
+    resolve_apps(ProjectApps, RawOpts).
+
+maybe_cover_compile(State, Opts) ->
+    State1 = case proplists:get_value(cover, Opts, false) of
+        true  -> rebar_state:set(State, cover_enabled, true);
+        false -> State
+    end,
+    rebar_prv_cover:maybe_cover_compile(State1).
 
-resolve_apps(State, RawOpts) ->
+resolve_apps(ProjectApps, RawOpts) ->
     case proplists:get_value(app, RawOpts) of
-        undefined -> resolve_suites(State, project_apps(State), RawOpts);
+        undefined -> resolve_suites(ProjectApps, RawOpts);
         %% convert app name strings to `rebar_app_info` objects
         Apps      -> AppNames = string:tokens(Apps, [$,]),
-                     ProjectApps = project_apps(State),
                      case filter_apps_by_name(AppNames, ProjectApps) of
-                         {ok, TestApps} -> resolve_suites(State, TestApps, RawOpts);
+                         {ok, TestApps} -> resolve_suites(TestApps, RawOpts);
                          Error          -> Error
                      end
     end.
 
-resolve_suites(State, Apps, RawOpts) ->
+resolve_suites(Apps, RawOpts) ->
     case proplists:get_value(suite, RawOpts) of
-        undefined  -> compile_tests(State, Apps, all, RawOpts);
+        undefined  -> test_set(Apps, all);
         Suites     -> SuiteNames = string:tokens(Suites, [$,]),
                       case filter_suites_by_apps(SuiteNames, Apps) of
-                          {ok, S} -> compile_tests(State, Apps, S, RawOpts);
+                          {ok, S} -> test_set(Apps, S);
                           Error   -> Error
                       end
     end.
 
-compile_tests(State, TestApps, Suites, RawOpts) ->
-    F = fun(AppInfo) ->
-        AppDir = rebar_app_info:dir(AppInfo),
-        S = case rebar_app_info:state(AppInfo) of
-            undefined ->
-                C = rebar_config:consult(AppDir),
-                rebar_state:new(State, C, AppDir);
-            AppState ->
-                AppState
-        end,
-        ok = rebar_erlc_compiler:compile(replace_src_dirs(S),
-                                         ec_cnv:to_list(rebar_app_info:out_dir(AppInfo)))
-    end,
-    lists:foreach(F, TestApps),
-    ok = maybe_cover_compile(State, RawOpts),
-    {ok, test_set(TestApps, Suites)}.
-
-maybe_cover_compile(State, Opts) ->
-    State1 = case proplists:get_value(cover, Opts, false) of
-        true  -> rebar_state:set(State, cover_enabled, true);
-        false -> State
-    end,
-    rebar_prv_cover:maybe_cover_compile(State1).
-
 project_apps(State) ->
     filter_checkouts(rebar_state:project_apps(State)).
 
@@ -219,14 +204,8 @@ app_modules([App|Rest], Acc) ->
             app_modules(Rest, NewAcc)
     end.
 
-replace_src_dirs(State) ->
-    %% replace any `src_dirs` with just the `test` dir
-    ErlOpts = rebar_state:get(State, erl_opts, []),
-    StrippedOpts = lists:keydelete(src_dirs, 1, ErlOpts),
-    rebar_state:set(State, erl_opts, [{src_dirs, ["test"]}|StrippedOpts]).
-
-test_set(Apps, all) -> set_apps(Apps, []);
-test_set(_Apps, Suites) -> set_suites(Suites, []).
+test_set(Apps, all) -> {ok, set_apps(Apps, [])};
+test_set(_Apps, Suites) -> {ok, set_suites(Suites, [])}.
 
 set_apps([], Acc) -> lists:reverse(Acc);
 set_apps([App|Rest], Acc) ->