Small refactoring on Mix tasks

Author: José Valim

lib/mix/lib/mix/project.ex

@@ -129,17 +129,17 @@ defmodule Mix.Project do
 
   defp default_config do
     [ compile_path: "ebin",
-      elixirc_exts: [:ex],
       default_env: [test: :test],
       default_task: "run",
       deps_path: "deps",
-      erlc_paths: ["src"],
-      erlc_include_path: "include",
-      erlc_options: [:debug_info],
+      elixirc_exts: [:ex],
+      elixirc_paths: ["lib"],
+      elixirc_watch_exts: [:ex, :eex, :exs],
       lockfile: "mix.lock",
       prepare_task: "app.start",
-      elixirc_paths: ["lib"],
-      elixirc_watch_exts: [:ex, :eex, :exs] ]
+      erlc_paths: ["src"],
+      erlc_include_path: "include",
+      erlc_options: [:debug_info] ]
   end
 
   defp get_project_config(nil), do: []

lib/mix/lib/mix/tasks/clean.ex

@@ -1,5 +1,6 @@
 defmodule Mix.Tasks.Clean do
   use Mix.Task
+  alias Mix.Tasks.Compile.Erlang
 
   @shortdoc "Clean generated application files"
 
@@ -15,10 +16,11 @@ defmodule Mix.Tasks.Clean do
     { opts, _ } = OptionParser.parse(args)
     File.rm_rf Mix.project[:compile_path]  || "ebin"
 
-    generated_source = lc source_path inlist Mix.project[:erlc_paths] do
-                         Mix.Utils.check_files(source_path, [:yrl, :xrl], source_path, :erl)
-                       end |> List.flatten
-    lc {_, output} inlist generated_source, do: File.rm_rf output
+    Enum.each Mix.project[:erlc_paths], fn(source_path) ->
+      pairs = Erlang.extract_stale_pairs(source_path, [:yrl, :xrl], source_path, :erl, true)
+      Enum.each pairs, fn { _, output } -> File.rm_rf output end
+    end
+
     if opts[:all], do: Mix.Task.run("deps.clean")
   end
 end

lib/mix/lib/mix/tasks/compile.erlang.ex

@@ -1,11 +1,9 @@
 defmodule Mix.Tasks.Compile.Erlang do
-
   alias :epp, as: Epp
   alias :digraph, as: Graph
   alias :digraph_utils, as: GraphUtils
-  alias :code, as: Code
-  alias :compile, as: Compiler
   alias Mix.Utils
+
   use Mix.Task
 
   @hidden true
@@ -29,7 +27,7 @@ defmodule Mix.Tasks.Compile.Erlang do
 
   ## Command line options
 
-  * `--force` - forces compilation regardless of module times;
+  * `--force` - forces compilation regardless of module times
 
   ## Configuration
 
@@ -47,19 +45,11 @@ defmodule Mix.Tasks.Compile.Erlang do
 
         [`erlc_include_path`: "other"]
 
-  * `:erlc_options` - compilation options that applies
-     to Erlang's compiler.
-     This options are setted:
-
-     :outdir to a configured :compile_path
-     :i to a configured :include_path
-     :report
-
-     and :debug_info in project configuration
+  * `:erlc_options` - compilation options that applies to Erlang's
+     compiler. `:debug_info` is enabled by default.
 
-     There are many other available options here:
+     There are many available options here:
      http://www.erlang.org/doc/man/compile.html#file-2
-
   """
 
   defrecord Erl, file: nil, module: nil, behaviours: [], compile: [],
@@ -68,23 +58,26 @@ defmodule Mix.Tasks.Compile.Erlang do
   def run(args) do
     { opts, _ } = OptionParser.parse(args, switches: [force: :boolean])
 
-    project = Mix.project
+    project      = Mix.project
     source_paths = project[:erlc_paths]
     files        = Mix.Utils.extract_files(source_paths, [:erl])
     compile_path = to_erl_file project[:compile_path]
     include_path = to_erl_file project[:erlc_include_path]
 
-    erlc_options = [{:outdir, compile_path}, {:i, include_path}, :report
-                    | project[:erlc_options] || []]
-    erlc_options = Enum.map erlc_options, fn(opt) ->
-      case opt do
-        { :i, dir } -> { :i, to_erl_file(dir) }
-        _           -> opt
-      end
+    erlc_options = project[:erlc_options] || []
+    erlc_options = erlc_options ++ [{:outdir, compile_path}, {:i, include_path}, :report]
+    erlc_options = Enum.map erlc_options, fn
+      { kind, dir } when kind in [:i, :outdit] ->
+        { kind, to_erl_file(dir) }
+      opt ->
+        opt
     end
 
-    files = files |> scan_sources(include_path, source_paths) |> sort_dependency
-    unless opts[:force], do: files = Enum.filter(files, check_file(compile_path, &1))
+    files = files |> scan_sources(include_path, source_paths) |> sort_dependencies
+
+    unless opts[:force] do
+      files = Enum.filter(files, requires_compilation?(compile_path, &1))
+    end
 
     if files == [] do
       :noop
@@ -99,67 +92,69 @@ defmodule Mix.Tasks.Compile.Erlang do
   end
 
   defp scan_sources(files, include_path, source_paths) do
-    include_pathes = [include_path | source_paths]
-    List.foldl(files, [], fn(file, acc) -> scan_source(acc, file, include_pathes) end) |> Enum.reverse
+    include_paths = [include_path | source_paths]
+    Enum.reduce(files, [], scan_source(&2, &1, include_paths)) |> Enum.reverse
   end
 
-  defp scan_source(acc, file, include_pathes) do
-    erl_file = Erl[mtime: Utils.last_modified(file),
-                   file: file,
-                   module: Path.basename(file, ".erl")]
-    case Epp.parse_file(to_erl_file(file), include_pathes, []) do
-      {:ok, forms} ->
-        [List.foldl(tl(forms), erl_file, fn(f, acc) -> do_form(file, f, acc) end) | acc]
-      {:error, _error} ->
+  defp scan_source(acc, file, include_paths) do
+    erl_file = Erl[file: file, module: Path.basename(file, ".erl")]
+
+    case Epp.parse_file(to_erl_file(file), include_paths, []) do
+      { :ok, forms } ->
+        [List.foldl(tl(forms), erl_file, do_form(file, &1, &2)) | acc]
+      { :error, _error } ->
         acc
     end
   end
 
-  defp do_form(file, form, erl) do
+  defp do_form(file, form, Erl[] = erl) do
     case form do
       {:attribute, _, :file, {include_file, _}} when file != include_file ->
-        erl.update(includes: [include_file | erl.includes])
+        if File.regular?(include_file) do
+          erl.update_includes [include_file|&1]
+        else
+          erl
+        end
       {:attribute, _, :behaviour, behaviour} ->
-        erl.update(behaviour: [behaviour | erl.behaviours])
+        erl.update_behaviours [behaviour|&1]
       {:attribute, _, :compile, value} ->
-        erl.update(compile: [value | erl.compile])
+        erl.update_compile [value|&1]
       _ ->
         erl
     end
   end
 
-  defp sort_dependency(erls) do
+  defp sort_dependencies(erls) do
     graph = Graph.new
+
     lc erl inlist erls do
       Graph.add_vertex(graph, erl.module, erl)
     end
+
     lc erl inlist erls do
       lc b inlist erl.behaviours, do: Graph.add_edge(graph, b, erl.module)
-      lc a inlist erl.compile do
-        case a do
-          {:parse_transform, transform} -> Graph.add_edge(graph, transform, erl.module);
+      lc c inlist erl.compile do
+        case c do
+          {:parse_transform, transform} -> Graph.add_edge(graph, transform, erl.module)
           _ -> :ok
         end
       end
     end
+
     result =
       case GraphUtils.topsort(graph) do
-        :false -> erls;
-        mods   ->
+        false -> erls
+        mods  ->
           lc m inlist mods, do: elem(Graph.vertex(graph, m), 1)
       end
+
     Graph.delete(graph)
     result
   end
 
-  defp check_file(compile_path, erl) do
-    beam = Path.join(compile_path, "#{erl.module}#{Code.objfile_extension}")
-    case File.regular?(beam) do
-      :false -> :true
-      :true  ->
-        beammtime = Utils.last_modified(beam)
-        (beammtime <= erl.mtime) or Utils.check_mtime(beammtime, erl.includes)
-    end
+  defp requires_compilation?(compile_path, erl) do
+    beam = Path.join(compile_path, "#{erl.module}#{:code.objfile_extension}")
+    Utils.stale?([erl.file|erl.includes], [beam])
   end
 
   defp compile_files(files, compile_path, erlc_options) do
@@ -172,17 +167,45 @@ defmodule Mix.Tasks.Compile.Erlang do
     interpret_result file, :compile.file(file, erlc_options), ".erl"
   end
 
+  ## Helpers shared accross erlang compilers
+
+  @doc """
+  Extract stale pairs considering the set of directories
+  and filename extensions. It first looks up the `dir1`
+  for files with `ext1` extensions and then recursively
+  try to find matching pairs in `dir2` with `ext2`
+  extension.
+  """
+  def extract_stale_pairs(dir1, ext1, dir2, ext2, force) do
+    files = Mix.Utils.extract_files([dir1], List.wrap(ext1))
+    Enum.reduce files, [], fn(file, acc) ->
+      compiled_file = Path.rootname(file) |> Path.basename
+      compiled_file = Path.join(dir2, compiled_file <> "." <> to_binary(ext2))
+      if force or Mix.Utils.stale?([file], [compiled_file]) do
+        [{file, compiled_file} | acc]
+      else
+        acc
+      end
+    end
+  end
+
+  @doc """
+  Interprets compilation results and prints them to the console.
+  """
   def interpret_result(file, result, ext // "") do
     case result do
-      { :ok, _} ->
-        Mix.shell.info  "Compiled #{file}#{ext}"
-      :error     ->
+      { :ok, _ } ->
+        Mix.shell.info "Compiled #{file}#{ext}"
+      :error ->
         :ok
     end
   end
 
-  def to_erl_file file do
+  @doc """
+  Converts the given file to a format accepted by
+  Erlang compilation tools.
+  """
+  def to_erl_file(file) do
     to_char_list(file)
   end
-
 end

lib/mix/lib/mix/tasks/compile.leex.ex

@@ -1,9 +1,7 @@
 defmodule Mix.Tasks.Compile.Leex do
-
-  alias :compile, as: Compiler
   alias :leex, as: Leex
-  alias Mix.Utils
   alias Mix.Tasks.Compile.Erlang
+
   use Mix.Task
 
   @hidden true
@@ -30,35 +28,20 @@ defmodule Mix.Tasks.Compile.Leex do
         [erlc_paths: ["src", "other"]]
 
   * `:leex_options` - compilation options that applies
-     to Leex's compiler.
-     This options are setted:
-
-     :scannerfile
-     {:report, true}
-
-     There are many other available options here:
-     http://www.erlang.org/doc/man/leex.html#file-2
+     to Leex's compiler. There are many available options
+     here: http://www.erlang.org/doc/man/leex.html#file-2
 
   """
-
   def run(args) do
     { opts, _ } = OptionParser.parse(args, switches: [force: :boolean])
 
-    project = Mix.project
+    project      = Mix.project
     source_paths = project[:erlc_paths]
 
-    checkfun = if opts[:force] do
-        fn(_, _) -> true end
-      else
-        fn(f1, f2) ->
-          mtime = Utils.last_modified(f2)
-          Utils.check_mtime(mtime, [f1])
-        end
-      end
-
     files = lc source_path inlist source_paths do
-              Utils.check_files(source_path, :xrl, source_path, :erl, checkfun)
+              Erlang.extract_stale_pairs(source_path, :xrl, source_path, :erl, opts[:force])
             end |> List.flatten
+
     if files == [] do
       :noop
     else
@@ -67,13 +50,12 @@ defmodule Mix.Tasks.Compile.Leex do
     end
   end
 
-  def compile_files(files, options) do
+  defp compile_files(files, options) do
     lc {input, output} inlist files do
-      Erlang.interpret_result(input, Leex.file(Erlang.to_erl_file(input),
-                                               [{:scannerfile, Erlang.to_erl_file(output)},
-                                                {:report, true} | options]))
+      options = options ++ [scannerfile: Erlang.to_erl_file(output), report: true]
+      Erlang.interpret_result(input,
+        Leex.file(Erlang.to_erl_file(input), options))
     end
   end
-
 end