Merge pull request #26 from clojerl/compile-files-first-option

Adapt plugin to be able to compile Clojerl with it

Author: jfacorro

src/rebar3_clojerl.erl

@@ -7,7 +7,6 @@ init(State) ->
   Commands = [ fun rebar3_clojerl_prv_compile:init/1
              , fun rebar3_clojerl_prv_test:init/1
              , fun rebar3_clojerl_prv_repl:init/1
-             , fun rebar3_clojerl_prv_release:init/1
              ],
   FoldFun  = fun(F, {ok, StateAcc}) -> F(StateAcc) end,
   lists:foldl(FoldFun, {ok, State}, Commands).

src/rebar3_clojerl_prv_compile.erl

@@ -6,7 +6,7 @@
 
 -define(PROVIDER, compile).
 -define(NAMESPACE, clojerl).
--define(DEPS, [{default, compile}]).
+-define(DEPS, [{default, lock}]).
 
 -type config() :: #{ ebin_dir      => file:name()
                    , protocols_dir => file:name()
@@ -34,17 +34,29 @@ init(State) ->
 
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
-  DepsPaths = rebar_state:code_paths(State, all_deps),
-  ok        = code:add_pathsa(DepsPaths),
-  ok        = rebar3_clojerl_utils:ensure_clojerl(State),
+  DepsPaths   = rebar_state:code_paths(State, all_deps),
+  ok          = code:add_pathsa(DepsPaths),
 
-  AllApps   = rebar3_clojerl_utils:all_apps(State),
-  Apps      = rebar3_clojerl_utils:filter_app(AllApps, ?CLOJERL),
-  Config    = #{protocols_dir => protocols_dir(State)},
+  ProjectApps = rebar_state:project_apps(State),
+  Deps        = rebar_state:all_deps(State),
 
-  restore_duplicates(AllApps),
-  [compile(AppInfo, Config) || AppInfo <- Apps],
-  backup_duplicates(AllApps, Config),
+  AppsPaths   = [rebar_app_info:ebin_dir(AppInfo) || AppInfo <- ProjectApps],
+  ok          = code:add_pathsa(AppsPaths),
+
+  ok          = rebar3_clojerl_utils:ensure_clojerl(),
+
+  Apps0       = Deps ++ ProjectApps,
+  Config      = #{protocols_dir => protocols_dir(State)},
+
+  %% More than one application might modify existing protocols, so we
+  %% restore the original backed-up protocol modules before compiling.
+  try
+    restore_duplicates(DepsPaths),
+    Apps1 = maybe_compile_clojerl(Apps0, Config),
+    [compile(AppInfo, Config) || AppInfo <- Apps1]
+  after
+    backup_duplicates(DepsPaths, Config)
+  end,
 
   {ok, State}.
 
@@ -64,13 +76,23 @@ protocols_dir(State) ->
   rebar_api:debug("Protocols dir: ~s", [ProtoDir]),
   ProtoDir.
 
+-spec maybe_compile_clojerl([rebar_app_info:t()], config()) ->
+  [rebar_app_info:t()].
+maybe_compile_clojerl(Apps, Config) ->
+  case rebar3_clojerl_utils:find_app(Apps, ?CLOJERL) of
+    notfound -> Apps;
+    {ok, ClojerlApp} ->
+      compile(ClojerlApp, Config),
+      Apps -- [ClojerlApp]
+  end.
+
 -spec backup_duplicates([rebar_app_info:t()], config()) -> ok.
-backup_duplicates(Apps, Config) ->
+backup_duplicates(DepsDirs, Config) ->
   ProtoDir      = maps:get(protocols_dir, Config),
   BeamFilepaths = rebar_utils:find_files(ProtoDir, ".beam$"),
   BeamFilenames = [filename:basename(F) || F <- BeamFilepaths],
 
-  Dirs    = [rebar_app_info:ebin_dir(App) || App <- Apps] -- [ProtoDir],
+  Dirs    = DepsDirs -- [ProtoDir],
   rebar_api:debug("Finding duplicates for:~n~p~nin~n~p", [BeamFilenames, Dirs]),
   Deleted = [backup_duplicates_from_dir(BeamFilenames, Dir) || Dir <- Dirs],
 
@@ -89,9 +111,8 @@ backup_duplicates_from_dir(BeamFilenames, Dir) ->
               ],
   {Dir, Filepaths}.
 
--spec restore_duplicates([rebar_app_info:t()]) -> ok.
-restore_duplicates(Apps) ->
-  Dirs = [rebar_app_info:ebin_dir(App) || App <- Apps],
+-spec restore_duplicates([file:name()]) -> ok.
+restore_duplicates(Dirs) ->
   [ begin
       DestPath = filename:rootname(Path),
       ok       = file:rename(Path, DestPath),
@@ -132,15 +153,18 @@ update_app_file({Dir, Filepaths}) ->
 compile(AppInfo, Config0) ->
   Graph   = load_graph(AppInfo),
   Config1 = Config0#{graph => Graph},
-  try find_files_to_compile(AppInfo, Config1) of
+  try find_files_to_compile(AppInfo) of
     [] ->
       false;
     SrcFiles ->
       rebar_api:info("Clojerl Compiling ~s", [rebar_app_info:name(AppInfo)]),
-      EbinDir = rebar_app_info:ebin_dir(AppInfo),
+      rebar_api:debug("Files to compile: ~p", [SrcFiles]),
+      EbinDir  = rebar_app_info:ebin_dir(AppInfo),
+      ProtoDir = list_to_binary(maps:get(protocols_dir, Config1)),
       Config2 = Config1#{ebin_dir => EbinDir},
       [ compile_clje(Src, Config2#{src_dir => SrcDir})
-        || {SrcDir, Src} <- SrcFiles
+        || {SrcDir, Src} <- SrcFiles,
+           should_compile_file(Src, SrcDir, EbinDir, ProtoDir, Graph)
       ],
       store_graph(AppInfo, Graph),
       true
@@ -150,7 +174,7 @@ compile(AppInfo, Config0) ->
 
 -spec compile_clje(file:name(), config()) -> ok.
 compile_clje(Src, Config) ->
-  rebar_api:debug("Compiling ~s...", [Src]),
+  io:format("%%% Compiling ~s...~n", [Src]),
 
   SrcDir   = list_to_binary(maps:get(src_dir, Config)),
   EbinDir  = list_to_binary(maps:get(ebin_dir, Config)),
@@ -163,8 +187,9 @@ compile_clje(Src, Config) ->
                },
   try
     ok      = 'clojerl.Var':push_bindings(Bindings),
-    Targets = clj_compiler:compile_file(list_to_binary(Src)),
-    update_graph(remove_src_dir(Src, SrcDir), Targets, Graph)
+    FullSrc = filename:join(SrcDir, Src),
+    Targets = clj_compiler:compile_file(FullSrc),
+    update_graph(Src, Targets, Graph)
   catch
     _:Reason ->
       Stacktrace = erlang:get_stacktrace(),
@@ -227,34 +252,29 @@ cljinfo_file(AppInfo) ->
 %% =============================================================================
 %% Find files to compile
 
--spec find_files_to_compile(rebar_app_info:t(), config()) ->
-  [{file:name(), file:name()}].
-find_files_to_compile(AppInfo, Config) ->
-  Graph       = maps:get(graph, Config),
-  ProtoDir    = maps:get(protocols_dir, Config),
+-spec find_files_to_compile(rebar_app_info:t()) -> [{file:name(), file:name()}].
+find_files_to_compile(AppInfo) ->
   OutDir      = rebar_app_info:out_dir(AppInfo),
-  EbinDir     = rebar_app_info:ebin_dir(AppInfo),
   CljeSrcDirs = rebar_app_info:get(AppInfo, clje_src_dirs, ?DEFAULT_SRC_DIRS),
+  CljeFirst   = clje_compile_first(AppInfo),
+  CljeExclude = rebar_app_info:get(AppInfo, clje_exclude, []),
 
   SrcDirPaths = [filename:join(OutDir, Dir) || Dir <- CljeSrcDirs],
   ok          = code:add_pathsa(SrcDirPaths),
-  Fun         = fun(SrcDir) ->
-                    find_files_to_compile(SrcDir, EbinDir, ProtoDir, Graph)
-                end,
 
-  lists:flatmap(Fun, SrcDirPaths).
+  AllFiles    = lists:flatmap(fun find_files/1, SrcDirPaths),
+  SortFun     = fun({_, X}, {_, Y}) ->
+                    maps:get(X, CljeFirst, -1) > maps:get(Y, CljeFirst, -1)
+                end,
+  [ X
+    || {_, Src} = X <- lists:sort(SortFun, AllFiles),
+       not lists:member(Src, CljeExclude)
+  ].
 
--spec find_files_to_compile( file:name()
-                           , file:name()
-                           , file:name()
-                           , digraph:graph()
-                           ) -> [{file:name(), file:name()}].
-find_files_to_compile(SrcDir, EbinDirs, ProtoDir, Graph) ->
+-spec find_files(file:name()) -> [{file:name(), file:name()}].
+find_files(SrcDir) ->
   SrcFiles = rebar_utils:find_files(SrcDir, ".clj[ce]"),
-  [ {SrcDir, Source}
-    || Source <- SrcFiles,
-       should_compile_file(Source, SrcDir, EbinDirs, ProtoDir, Graph)
-  ].
+  [{SrcDir, remove_src_dir(Source, SrcDir)} || Source <- SrcFiles].
 
 -spec should_compile_file( file:name()
                          , file:name()
@@ -265,12 +285,12 @@ find_files_to_compile(SrcDir, EbinDirs, ProtoDir, Graph) ->
 should_compile_file(Src, SrcDir, EbinDir, ProtoDir, Graph) ->
   %% Check if the target file is either in the ebin directory or the
   %% protocols directory.
+  FullSrc = filename:join(SrcDir, Src),
   Fun = fun(Target) ->
-            should_compile(filename:join(ProtoDir, Target), Src) andalso
-            should_compile(filename:join(EbinDir, Target), Src)
+            should_compile(filename:join(ProtoDir, Target), FullSrc) andalso
+            should_compile(filename:join(EbinDir, Target), FullSrc)
         end,
-  SrcFilename = remove_src_dir(Src, SrcDir),
-  case digraph:out_neighbours(Graph, SrcFilename) of
+  case digraph:out_neighbours(Graph, Src) of
     []      -> true;
     Targets -> lists:any(Fun, Targets)
   end.
@@ -283,3 +303,12 @@ should_compile(Target, Source) ->
 -spec remove_src_dir(file:name(), file:name()) -> file:name().
 remove_src_dir(Src, SrcDir) ->
   re:replace(Src, ["^", SrcDir, "/"], "", [global, {return, list}]).
+
+-spec clje_compile_first(rebar_app_info:t()) -> #{list() => non_neg_integer()}.
+clje_compile_first(AppInfo) ->
+  CljeFirst = rebar_app_info:get(AppInfo, clje_compile_first, []),
+  Fun = fun (X, {Acc, N}) ->
+            {Acc#{X => N}, N - 1}
+        end,
+  {Positions, _} = lists:foldl(Fun, {#{}, length(CljeFirst)}, CljeFirst),
+  Positions.

src/rebar3_clojerl_prv_release.erl

@@ -32,14 +32,20 @@ init(State) ->
 
 -spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
 do(State) ->
+  rebar_api:info("Running Clojerl tests...", []),
+
   {Opts, _} = rebar_state:command_parsed_args(State),
   ok        = rebar3_clojerl_utils:maybe_set_sname(Opts),
 
   DepsPaths = rebar_state:code_paths(State, all_deps),
   ok        = code:add_pathsa(DepsPaths),
-  ok        = rebar3_clojerl_utils:ensure_clojerl(State),
 
   Apps      = rebar_state:project_apps(State),
+  AppsPaths = [rebar_app_info:ebin_dir(AppInfo) || AppInfo <- Apps],
+  ok        = code:add_pathsa(AppsPaths),
+
+  %% Ensure clojerl after adding all code pahts
+  ok        = rebar3_clojerl_utils:ensure_clojerl(),
 
   try
     [test(AppInfo, Opts) || AppInfo <- Apps]
@@ -69,7 +75,7 @@ test(AppInfo, Opts) ->
   NsOpt     = proplists:get_value(ns, Opts, undefined),
   VarOpt    = proplists:get_value(var, Opts, undefined),
 
-  NsSymbols = case NsOpt of
+  NsSyms0   = case NsOpt of
                 undefined -> lists:flatmap(fun find_tests/1, TestDirs);
                 NsOpt     -> [clj_rt:symbol(list_to_binary(NsOpt))]
               end,
@@ -80,7 +86,7 @@ test(AppInfo, Opts) ->
   'clojure.core':use([clj_rt:symbol(<<"clojure.core">>)]),
 
   %% TODO: maybe change this to a compilation of the file
-  'clojure.core':require(NsSymbols),
+  'clojure.core':require(NsSyms0),
 
   Var       = case {NsOpt, VarOpt} of
                 {undefined, _} -> undefined;
@@ -92,11 +98,14 @@ test(AppInfo, Opts) ->
                   'clojure.core':'find-var'(VarSymbol)
               end,
 
-  rebar_api:debug("Test namespaces: ~p", [clj_rt:str(NsSymbols)]),
-
   case Var of
-    undefined -> 'clojure.test':'run-tests'(NsSymbols);
-    _         -> 'clojure.test':'test-var'(Var)
+    undefined ->
+      NsSyms1 = [X || X <- NsSyms0, 'clojure.core':'find-ns'(X) =/= undefined],
+      rebar_api:debug("Test namespaces: ~s", [clj_rt:str(NsSyms1)]),
+      'clojure.test':'run-tests'(NsSyms1);
+    _         ->
+      rebar_api:debug("Test var: ~s", [clj_rt:str(Var)]),
+      'clojure.test':'test-var'(Var)
   end,
   ok.
 

src/rebar3_clojerl_prv_test.erl

@@ -2,7 +2,7 @@
 
 -include("rebar3_clojerl.hrl").
 
--export([ ensure_clojerl/1
+-export([ ensure_clojerl/0
         , all_apps/1
         , find_app/2
         , filter_app/2
@@ -11,13 +11,13 @@
 
 -type opts() :: [{atom(), any()}].
 
--spec ensure_clojerl(rebar_state:t()) -> ok.
-ensure_clojerl(State) ->
-  case find_app(all_apps(State), ?CLOJERL) of
-    notfound ->
-      rebar_api:abort("Clojerl was not found as a dependency", []);
-    {ok, _} ->
-      ok = clojerl:start()
+-spec ensure_clojerl() -> ok.
+ensure_clojerl() ->
+  case code:ensure_loaded(clojerl) of
+    {module, clojerl} ->
+      ok = clojerl:start();
+    {error, Reason} ->
+      rebar_api:abort("Application Clojerl could not be started: ~p", [Reason])
   end.
 
 -spec all_apps(rebar_state:t()) -> [rebar_app_info:t()].