Straight up and unify impls of clean, deps.clean and deps.unlock

Author: José Valim

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

@@ -7,37 +7,37 @@ defmodule Mix.Tasks.Clean do
   @moduledoc """
   Delete generated application files.
 
-  This command deletes all build artifacts for the current application
-  across all environments. Dependencies are only cleaned if the
-  `--all` option is given.
-
-  ## Command line options
-
-    * `--all` - clean everything, including builds and dependencies
+  This command deletes all build artifacts for the current project
+  Dependencies' build files are cleaned if the `--deps` option is given.
 
+  By default this task works accross all environments, unless `--only`
+  is given.
   """
 
+  @switches [deps: :boolean, only: :string]
+
   def run(args) do
     Mix.Project.get!
     loadpaths!
 
-    {opts, _, _} = OptionParser.parse(args)
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
 
     _ = for compiler <- Mix.Tasks.Compile.compilers(),
             module = Mix.Task.get("compile.#{compiler}"),
             function_exported?(module, :clean, 0),
             do: module.clean
 
-    if opts[:all] do
-      Mix.Task.run("deps.clean", args)
-      Mix.Project.build_path
-      |> Path.dirname
-      |> File.rm_rf
+    build = Mix.Project.build_path
+            |> Path.dirname
+            |> Path.join("#{opts[:only] || :*}")
+
+    if opts[:deps] do
+      build
+      |> Path.wildcard
+      |> Enum.each(&File.rm_rf/1)
     else
-      config = Mix.Project.config
-      Mix.Project.build_path(config)
-      |> Path.dirname
-      |> Path.join("*/lib/#{config[:app]}")
+      build
+      |> Path.join("lib/#{Mix.Project.config[:app]}")
       |> Path.wildcard
       |> Enum.each(&File.rm_rf/1)
     end

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

@@ -6,52 +6,66 @@ defmodule Mix.Tasks.Deps.Clean do
   @moduledoc """
   Remove the given dependencies' files.
 
-  Since this is a destructive action, cleaning of all dependencies
-  can only happen by passing the `--all` command line option. It
-  also works accross all environments, unless `--only` is given.
+  Since this is a destructive action, cleaning of dependencies
+  can only happen by passing arguments/options:
 
-  Clean does not unlock the dependencies, unless `--unlock` is given.
-  The `--unused` flag removes unused the dependencies.
+    * `dep1, dep2` - the name of dependency to be removed
+    * `--all` - removes all dependencies
+    * `--unused` - removes only unused dependencies (no longer mentioned
+      in the `mix.exs` file)
+
+  By default this task works accross all environments, unless `--only`
+  is given.
   """
+
   @switches [unlock: :boolean, all: :boolean, only: :string, unused: :boolean]
 
   def run(args) do
     Mix.Project.get!
-    {opts, args, _} = OptionParser.parse(args, switches: @switches)
+    {opts, apps, _} = OptionParser.parse(args, switches: @switches)
+
+    build = Mix.Project.build_path
+            |> Path.dirname
+            |> Path.join("#{opts[:only] || :*}/lib")
+    deps = Mix.Project.deps_path
 
     cond do
       opts[:all] ->
-        # Clean all deps by default unless --only is given
-        clean_opts = if only = opts[:only], do: [env: :"#{only}"], else: []
-        apps = Mix.Dep.loaded(clean_opts) |> Enum.map(&(&1.app))
-        do_clean apps, opts
+        checked_deps(build, deps) |> do_clean(build, deps)
       opts[:unused] ->
-        Mix.Dep.loaded([]) |> Enum.map(&(&1.app)) |> unused_apps |> do_clean opts
-      args != [] ->
-        do_clean args, opts
+        checked_deps(build, deps) |> filter_loaded(opts) |> do_clean(build, deps)
+      apps != [] ->
+        do_clean(apps, build, deps)
       true ->
         Mix.raise "mix deps.clean expects dependencies as arguments or " <>
                   "a flag indicating which dependencies to clean " <>
                   "The --all option will clean all dependencies while"
                   "the --unused option cleans unused dependencies."
     end
+
+    if opts[:unlock] do
+      Mix.Task.run "deps.unlock", args
+    end
   end
 
-  defp unused_apps(loaded_apps) do
-    case File.ls(Mix.Project.deps_path) do
-      {:ok, deps} ->
-        Enum.reject deps,
-          fn(x) -> not File.dir?(x) and Enum.member?(loaded_apps, String.to_atom(x)) end
-      {_, _} -> []
+  defp checked_deps(build, deps) do
+    for root <- [deps, build],
+        path <- Path.wildcard(Path.join(root, "*")),
+        File.dir?(path) do
+      Path.basename(path)
     end
+    |> Enum.uniq()
+    |> List.delete(to_string(Mix.Project.config[:app]))
   end
 
-  defp do_clean(apps, opts) do
+  defp filter_loaded(apps, opts) do
+    load_opts = if only = opts[:only], do: [env: :"#{only}"], else: []
+    load_deps = Mix.Dep.loaded(load_opts) |> Enum.map(&Atom.to_string(&1.app))
+    Enum.reject(apps, &(&1 in load_deps))
+  end
+
+  defp do_clean(apps, build, deps) do
     shell = Mix.shell
-    build = Mix.Project.build_path
-            |> Path.dirname
-            |> Path.join("#{opts[:only] || :*}/lib")
-    deps  = Mix.Project.deps_path
 
     Enum.each apps, fn(app) ->
       shell.info "* Cleaning #{app}"
@@ -65,9 +79,5 @@ defmodule Mix.Tasks.Deps.Clean do
       |> Path.join(to_string(app))
       |> File.rm_rf!
     end
-
-    if opts[:unlock] do
-      Mix.Task.run "deps.unlock", apps
-    end
   end
 end

lib/mix/lib/mix/tasks/deps.unlock.ex

@@ -6,28 +6,43 @@ defmodule Mix.Tasks.Deps.Unlock do
   @moduledoc """
   Unlock the given dependencies.
 
-  Since this is a destructive action, unlocking of all dependencies
-  can only happen by passing the `--all` command line option.
+  Since this is a destructive action, unlocking of dependencies
+  can only happen by passing arguments/options:
+
+    * `dep1, dep2` - the name of dependency to be unlocked
+    * `--all` - unlcks all dependencies
+    * `--unused` - unlocks only unused dependencies (no longer mentioned
+      in the `mix.exs` file)
+
   """
 
+  @switches [all: :boolean, unused: :boolean]
+
   def run(args) do
     Mix.Project.get!
-    {opts, args, _} = OptionParser.parse(args, switches: [all: :boolean])
+    {opts, apps, _} = OptionParser.parse(args, switches: @switches)
 
     cond do
       opts[:all] ->
         Mix.Dep.Lock.write([])
-      args != [] ->
+      opts[:unused] ->
+        apps = Mix.Dep.loaded([]) |> Enum.map(& &1.app)
+        Mix.Dep.Lock.read() |> Map.take(apps) |> Mix.Dep.Lock.write()
+
+      apps != [] ->
         lock =
-          Enum.reduce args, Mix.Dep.Lock.read, fn(arg, lock) ->
-            if is_binary(arg), do: arg = String.to_atom(arg)
-            Map.delete(lock, arg)
+          Enum.reduce apps, Mix.Dep.Lock.read, fn(app, lock) ->
+            Map.delete(lock, String.to_atom(app))
           end
-
         Mix.Dep.Lock.write(lock)
+
       true ->
         Mix.raise "mix deps.unlock expects dependencies as arguments or " <>
-                                  "the --all option to unlock all dependencies"
+                  "the --all option to unlock all dependencies"
     end
   end
+
+  defp unlock(apps) do
+
+  end
 end

lib/mix/test/mix/tasks/clean_test.exs

@@ -21,37 +21,30 @@ defmodule Mix.Tasks.CleanTest do
     :ok
   end
 
-  test "removes the build application" do
+  test "cleans the application build" do
     in_fixture "deps_status", fn ->
-      Mix.Tasks.Compile.run ["--no-deps"]
-      assert File.exists?("_build/dev/lib/sample")
+      File.mkdir_p! "_build/dev/lib/sample"
+      File.mkdir_p! "_build/test/lib/sample"
+      File.mkdir_p! "_build/dev/lib/ok"
 
       Mix.Tasks.Clean.run []
       refute File.exists?("_build/dev/lib/sample")
+      refute File.exists?("_build/test/lib/sample")
+      assert File.exists?("_build/dev/lib/ok")
     end
   end
 
-  test "cleans deps" do
+  test "cleans dependencies build" do
     in_fixture "deps_status", fn ->
-      assert File.exists?("_build/dev/lib/ok")
-      Mix.Tasks.Clean.run ["--all"]
+      File.mkdir_p! "_build/dev/lib/ok"
+      File.mkdir_p! "_build/test/lib/ok"
 
+      Mix.Tasks.Clean.run ["--deps", "--only", "dev"]
       refute File.exists?("_build/dev")
-      assert_received {:mix_shell, :info, ["* Cleaning ok"]}
-
-      # Assert we don't choke on unfetched deps
-      assert_received {:mix_shell, :info, ["* Cleaning unknown"]}
-    end
-  end
-
-  test "cleans all deps and builds" do
-    in_fixture "deps_status", fn ->
-      assert File.exists?("_build/dev/lib/ok")
-      Mix.Tasks.Clean.run ["--all"]
+      assert File.exists?("_build/test")
 
-      refute File.exists?("_build")
-      assert_received {:mix_shell, :info, ["* Cleaning ok"]}
-      assert_received {:mix_shell, :info, ["* Cleaning unknown"]}
+      Mix.Tasks.Clean.run ["--deps"]
+      refute File.exists?("_build/test")
     end
   end
 end

lib/mix/test/mix/tasks/deps_test.exs

@@ -183,6 +183,16 @@ defmodule Mix.Tasks.DepsTest do
     end
   end
 
+  test "unlocks unused deps" do
+    Mix.Project.push DepsApp
+    in_fixture "no_mixfile", fn ->
+      Mix.Dep.Lock.write %{whatever: "abcdef", ok: "abcdef"}
+      assert Mix.Dep.Lock.read == %{whatever: "abcdef", ok: "abcdef"}
+      Mix.Tasks.Deps.Unlock.run ["--unused"]
+      assert Mix.Dep.Lock.read == %{ok: "abcdef"}
+    end
+  end
+
   test "unlocks specific deps" do
     Mix.Project.push DepsApp
     in_fixture "no_mixfile", fn ->
@@ -531,12 +541,13 @@ defmodule Mix.Tasks.DepsTest do
     end
   end
 
-  test "clean all deps" do
+  test "cleans dependencies" do
     Mix.Project.push CleanDepsApp
 
     in_fixture "deps_status", fn ->
-      File.mkdir_p!("deps/git_repo")
+      File.mkdir_p!("_build/dev/lib/raw_sample")
       File.mkdir_p!("_build/dev/lib/git_repo")
+      File.mkdir_p!("_build/test/lib/git_repo")
 
       message = "mix deps.clean expects dependencies as arguments or " <>
                 "a flag indicating which dependencies to clean " <>
@@ -547,16 +558,23 @@ defmodule Mix.Tasks.DepsTest do
         Mix.Tasks.Deps.Clean.run []
       end
 
+      Mix.Tasks.Deps.Clean.run ["--only", "dev", "--all"]
+      refute File.exists?("_build/dev/lib/git_repo")
+      assert File.exists?("_build/test/lib/git_repo")
+      assert File.exists?("_build/dev/lib/raw_sample")
+
       Mix.Tasks.Deps.Clean.run ["--all"]
       refute File.exists?("_build/dev/lib/git_repo")
-      refute File.exists?("deps/git_repo")
+      refute File.exists?("_build/test/lib/git_repo")
+      assert File.exists?("_build/dev/lib/raw_sample")
     end
   end
 
-  test "clean unused" do
+  test "cleans unused dependencies" do
     Mix.Project.push CleanDepsApp
 
     in_fixture "deps_status", fn ->
+      File.mkdir_p!("_build/dev/lib/raw_sample")
       File.mkdir_p!("deps/git_repo")
       File.mkdir_p!("_build/dev/lib/git_repo")
       File.mkdir_p!("deps/git_repo_unused")
@@ -567,23 +585,7 @@ defmodule Mix.Tasks.DepsTest do
       assert File.exists?("_build/dev/lib/git_repo")
       refute File.exists?("deps/git_repo_unused")
       refute File.exists?("_build/dev/lib/git_repo_unused")
-    end
-  end
-
-  test "cleans dependencies" do
-    Mix.Project.push CleanDepsApp
-
-    in_fixture "deps_status", fn ->
-      File.mkdir_p!("_build/dev/lib/git_repo")
-      File.mkdir_p!("_build/test/lib/git_repo")
-
-      Mix.Tasks.Deps.Clean.run ["--only", "dev", "--all"]
-      refute File.exists?("_build/dev/lib/git_repo")
-      assert File.exists?("_build/test/lib/git_repo")
-
-      Mix.Tasks.Deps.Clean.run ["--all"]
-      refute File.exists?("_build/dev/lib/git_repo")
-      refute File.exists?("_build/test/lib/git_repo")
+      assert File.exists?("_build/dev/lib/raw_sample")
     end
   end
 end