Rename fetched to loaded and add a manifest_path

Author: José Valim

lib/mix/lib/mix/deps.ex

@@ -35,13 +35,13 @@ defmodule Mix.Deps do
 
   Inside Mix, those dependencies are converted to a `Mix.Dep` record.
   This module provides conveniences to work with those dependencies
-  and the dependencies are usually in two specific states: fetched and
-  unfetched.
+  and the dependencies are usually in two specific states: loaded and
+  unloaded.
 
-  When a dependency is unfetched, it means Mix only parsed its specification
-  and made no attempt to actually fetch the dependency or validate its
-  status. When the dependency is fetched, it means Mix attempted to fetch
-  and validate it, the status is set in the status field.
+  When a dependency is unloaded, it means Mix only parsed its specification
+  and made no attempt to actually load the dependency or validate its
+  status. When the dependency is loaded, it means Mix attempted to fetch,
+  load and validate it, the status is set in the status field.
 
   ## Mix options
 
@@ -80,7 +80,7 @@ defmodule Mix.Deps do
   Returns all children dependencies for the current project,
   as well as the defined apps in case of umbrella projects.
   The children dependencies returned by this function were
-  not fetched yet.
+  not loaded yet.
 
   ## Exceptions
 
@@ -90,28 +90,28 @@ defmodule Mix.Deps do
   defdelegate children(), to: Mix.Deps.Retriever
 
   @doc """
-  Returns fetched dependencies recursively as a `Mix.Dep` record.
+  Returns loaded dependencies recursively as a `Mix.Dep` record.
 
   ## Exceptions
 
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def fetched do
+  def loaded do
     { deps, _ } = Mix.Deps.Converger.all(nil, fn(dep, acc) -> { dep, acc } end)
     Mix.Deps.Converger.topsort(deps)
   end
 
   @doc """
-  Receives a list of  dependency names and returns fetched dependency
+  Receives a list of  dependency names and returns loaded dependency
   records. Logs a message if the dependency could not be found.
 
   ## Exceptions
 
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def fetched_by_name(given, all_deps // fetched) do
+  def loaded_by_name(given, all_deps // loaded) do
     # Ensure all apps are atoms
     apps = to_app_names(given)
 
@@ -130,7 +130,7 @@ defmodule Mix.Deps do
   end
 
   @doc """
-  Maps and reduces over all unfetched dependencies, one by one.
+  Maps and reduces over all unloaded dependencies, one by one.
 
   This is useful in case you want to retrieve the dependency
   tree for a project but process and change them along the way.
@@ -145,7 +145,7 @@ defmodule Mix.Deps do
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def unfetched(acc, callback) do
+  def unloaded(acc, callback) do
     { deps, acc } = Mix.Deps.Converger.all(acc, callback)
     { Mix.Deps.Converger.topsort(deps), acc }
   end
@@ -159,10 +159,10 @@ defmodule Mix.Deps do
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def unfetched_by_name(given, acc, callback) do
+  def unloaded_by_name(given, acc, callback) do
     names = to_app_names(given)
 
-    unfetched(acc, fn(dep, acc) ->
+    unloaded(acc, fn(dep, acc) ->
       if dep.app in names do
         callback.(dep, acc)
       else
@@ -177,7 +177,7 @@ defmodule Mix.Deps do
   project onto the project stack.
 
   This function only works for mix dependencies.
-  It is expected a fetched dependency as argument.
+  It is expected a loaded dependency as argument.
   """
   def in_dependency(dep, post_config // [], fun)
 
@@ -339,7 +339,7 @@ defmodule Mix.Deps do
 
   @doc """
   Returns all load paths for the dependency.
-  Expects a fetched dependency.
+  Expects a loaded dependency.
   """
   def load_paths(Mix.Dep[manager: :mix, opts: opts]) do
     [Path.join(opts[:build], "ebin")]
@@ -388,7 +388,7 @@ defmodule Mix.Deps do
   @doc false
   # Called by deps.get and deps.update
   def finalize(all_deps, apps, lock, opts) do
-    deps = fetched_by_name(apps, all_deps)
+    deps = loaded_by_name(apps, all_deps)
 
     # Do not attempt to compile dependencies that are not available.
     # mix deps.check at the end will emit proper status in case they failed.

lib/mix/lib/mix/deps/converger.ex

@@ -95,9 +95,9 @@ defmodule Mix.Deps.Converger do
         { dep, rest } = callback.(dep, rest)
 
         # After we invoke the callback (which may actually check out the
-        # dependency), we fetch the dependency including its latest info
+        # dependency), we load the dependency including its latest info
         # and children information.
-        { dep, children } = Mix.Deps.Retriever.fetch(dep, config)
+        { dep, children } = Mix.Deps.Retriever.load(dep, config)
         children = reject_non_fullfilled_optional(children, current_breadths)
         dep      = dep.deps(Enum.map(children, &(&1.app)))
 

lib/mix/lib/mix/deps/lock.ex

@@ -10,16 +10,16 @@ defmodule Mix.Deps.Lock do
   Returns the manifest file for dependencies.
   """
   def manifest do
-    Path.join(Mix.Project.compile_path, @manifest)
+    Path.join(Mix.Project.manifest_path, @manifest)
   end
 
   @doc """
   Touches the manifest timestamp and updates the elixir version.
   """
   def touch do
-    compile_path = Mix.Project.compile_path
-    File.mkdir_p!(compile_path)
-    File.write!(Path.join(compile_path, @manifest), System.version)
+    manifest_path = Mix.Project.manifest_path
+    File.mkdir_p!(manifest_path)
+    File.write!(Path.join(manifest_path, @manifest), System.version)
   end
 
   @doc """

lib/mix/lib/mix/deps/retriever.ex

@@ -13,14 +13,14 @@ defmodule Mix.Deps.Retriever do
     scms = Mix.SCM.available
     from = Path.absname("mix.exs")
     Enum.map(Mix.project[:deps] || [], &to_dep(&1, scms, from)) ++
-             Mix.Deps.Umbrella.unfetched
+             Mix.Deps.Umbrella.unloaded
   end
 
   @doc """
-  Fetches the given dependency information, including its
+  Loads the given dependency information, including its
   latest status and children.
   """
-  def fetch(dep, config) do
+  def load(dep, config) do
     Mix.Dep[manager: manager, scm: scm, opts: opts] = dep
     dep  = dep.status(scm_status(scm, opts))
     dest = opts[:dest]

lib/mix/lib/mix/deps/umbrella.ex

@@ -2,9 +2,9 @@ defmodule Mix.Deps.Umbrella do
   @moduledoc false
 
   @doc """
-  Gets all umbrella dependencies in unfetched format.
+  Gets all umbrella dependencies in unloaded format.
   """
-  def unfetched do
+  def unloaded do
     config = Mix.project
 
     if apps_path = config[:apps_path] do
@@ -21,14 +21,14 @@ defmodule Mix.Deps.Umbrella do
   end
 
   @doc """
-  Gets all umbrella dependencies in fetched format.
+  Gets all umbrella dependencies in the loaded format.
   """
-  def fetched do
-    deps = unfetched
+  def loaded do
+    deps = unloaded
     apps = Enum.map(deps, &(&1.app))
 
     Enum.map(deps, fn(umbrella_dep) ->
-      { umbrella_dep, deps } = Mix.Deps.Retriever.fetch(umbrella_dep, [])
+      { umbrella_dep, deps } = Mix.Deps.Retriever.load(umbrella_dep, [])
       deps = lc Mix.Dep[] = dep inlist deps,
                 Mix.Deps.available?(dep),
                 dep.app in apps,

lib/mix/lib/mix/project.ex

@@ -192,6 +192,23 @@ defmodule Mix.Project do
     config[:build_path] || Path.expand("_build")
   end
 
+  @doc """
+  The path to store manifests. By default they are
+  stored in the same app path but it may be changed
+  in future releases.
+
+  The returned path will be expanded.
+
+  ## Examples
+
+      Mix.Project.manifest_path
+      #=> "/path/to/project/_build/lib/app"
+
+  """
+  def manifest_path(config // config()) do
+    app_path(config)
+  end
+
   @doc """
   Returns the library path inside the build.
   The returned path will be expanded.

lib/mix/lib/mix/task.ex

@@ -211,7 +211,7 @@ defmodule Mix.Task do
     recursive = recursive(module)
 
     if umbrella? && recursive && Mix.ProjectStack.enable_recursion do
-      res = lc Mix.Dep[app: app, opts: opts] inlist Mix.Deps.Umbrella.fetched do
+      res = lc Mix.Dep[app: app, opts: opts] inlist Mix.Deps.Umbrella.loaded do
         Mix.Project.in_project(app, opts[:path], fun)
       end
       Mix.ProjectStack.disable_recursion

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

@@ -24,8 +24,7 @@ defmodule Mix.Tasks.Clean do
       File.rm(manifest)
     end)
 
-    File.rm_rf(Mix.Project.compile_path)
-
+    File.rm_rf(Mix.Project.app_path)
     if opts[:all], do: Mix.Task.run("deps.clean", args)
   end
 end

lib/mix/lib/mix/tasks/compile.elixir.ex

@@ -261,7 +261,7 @@ defmodule Mix.Tasks.Compile.Elixir do
   Returns Elixir manifests.
   """
   def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.compile_path, @manifest)
+  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
 
   @doc """
   Compiles stale Elixir files.

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

@@ -96,7 +96,7 @@ defmodule Mix.Tasks.Compile.Erlang do
   Returns Erlang manifests.
   """
   def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.compile_path, @manifest)
+  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
 
   @doc """
   Extracts the extensions from the mappings, automatically
@@ -110,7 +110,7 @@ defmodule Mix.Tasks.Compile.Erlang do
   For example, a simple compiler for Lisp Flavored Erlang
   would be implemented like:
 
-      compile_mappings "ebin/.compile.lfe",
+      compile_mappings ".compile.lfe",
                        [{ "src", "ebin" }],
                        :lfe, :beam, opts[:force], fn
         input, output ->