@spec app_path(keyword()) :: Path.t()

Returns the application path inside the build.

The returned path will be expanded.

Examples

Mix.Project.app_path()
#=> "/path/to/project/_build/shared/lib/app"

@spec apps_paths(keyword()) :: %{optional(atom()) => Path.t()} | nil

Returns a map with the umbrella child applications paths.

These paths are based on the :apps_path and :apps configurations.

If the given project configuration identifies an umbrella project, the return value is a map of app => path where app is a child app of the umbrella and path is its path relative to the root of the umbrella project.

If the given project configuration does not identify an umbrella project, nil is returned.

Examples

Mix.Project.apps_paths()
#=> %{my_app1: "apps/my_app1", my_app2: "apps/my_app2"}

@spec build_path(keyword()) :: Path.t()

Returns the build path for the given project.

If no configuration is given, the one for the current project is used.

The returned path will be expanded.

Examples

Mix.Project.build_path()
#=> "/path/to/project/_build/shared"

If :build_per_environment is set to true, it will create a new build per environment:

Mix.env()
#=> :dev
Mix.Project.build_path()
#=> "/path/to/project/_build/dev"

@spec build_structure(keyword(), keyword()) :: :ok

Builds the project structure for the given application.

Options

• :symlink_ebin - symlink ebin instead of copying it

@spec clear_deps_cache() :: :ok

Clears the dependency for the current environment.

Useful when dependencies need to be reloaded due to change of global state.

@spec compile([term()], keyword()) :: term()

Compiles the given project.

@spec compile_path(keyword()) :: Path.t()

Returns the paths the given project compiles to.

If no configuration is given, the one for the current project will be used.

The returned path will be expanded.

Examples

Mix.Project.compile_path()
#=> "/path/to/project/_build/dev/lib/app/ebin"

@spec config() :: keyword()

Returns the project configuration.

If there is no project defined, it still returns a keyword list with default values. This allows many Mix tasks to work without the need for an underlying project.

Note this configuration is cached once the project is pushed onto the stack. Calling it multiple times won't cause it to be recomputed.

Do not use Mix.Project.config/0 to find the runtime configuration. Use it only to configure aspects of your project (like compilation directories) and not your application runtime.

@spec config_files() :: [Path.t()]

Returns a list of project configuration files for this project.

This function is usually used in compilation tasks to trigger a full recompilation whenever such configuration files change.

It returns the mix.exs file, the lock manifest, and all config files in the config directory that do not start with a leading period (for example, .my_config.exs).

@spec config_mtime() :: posix_mtime when posix_mtime: integer()

Returns the latest modification time from config files.

This function is usually used in compilation tasks to trigger a full recompilation whenever such configuration files change. For this reason, the mtime is cached to avoid file system lookups.

@spec consolidation_path(keyword()) :: Path.t()

Returns the path where protocol consolidations are stored.

The returned path will be expanded.

Examples

Mix.Project.consolidation_path()
#=> "/path/to/project/_build/dev/lib/my_app/consolidated"

Inside umbrellas:

Mix.Project.consolidation_path()
#=> "/path/to/project/_build/dev/consolidated"

@spec deps_path(keyword()) :: Path.t()

Returns the path where dependencies are stored for the given project.

If no configuration is given, the one for the current project is used.

The returned path will be expanded.

Examples

Mix.Project.deps_path()
#=> "/path/to/project/deps"

@spec deps_paths(keyword()) :: %{optional(atom()) => Path.t()}

Returns the full path of all dependencies as a map.

Options

• :depth - only returns dependencies to the depth level, a depth of 1 will only return top-level dependencies
• :parents - starts the dependency traversal from the given parents instead of the application root

Examples

Mix.Project.deps_paths()
#=> %{foo: "deps/foo", bar: "custom/path/dep"}

@spec deps_scms(keyword()) :: %{optional(atom()) => Mix.SCM.t()}

Returns the SCMs of all dependencies as a map.

See Mix.SCM module documentation to learn more about SCMs.

Options

• :depth - only returns dependencies to the depth level, a depth of 1 will only return top-level dependencies
• :parents - starts the dependency traversal from the given parents instead of the application root

Examples

Mix.Project.deps_scms()
#=> %{foo: Mix.SCM.Path, bar: Mix.SCM.Git}

@spec ensure_structure(keyword(), keyword()) :: :ok

Ensures the project structure for the given project exists.

In case it does exist, it is a no-op. Otherwise, it is built.

@spec get() :: module() | nil

Retrieves the current project if there is one.

If there is no current project, nil is returned. This may happen in cases there is no mix.exs in the current directory.

If you expect a project to be defined, i.e., it is a requirement of the current task, you should call get!/0 instead.

@spec get!() :: module()

Same as get/0, but raises an exception if there is no current project.

This is usually called by tasks that need additional functions on the project to be defined. Since such tasks usually depend on a project being defined, this function raises a Mix.NoProjectError exception in case no project is available.

@spec in_project(atom(), Path.t(), keyword(), (module() -> result)) :: result
when result: term()

Runs the given fun inside the given project.

This function changes the current working directory and loads the project at the given directory onto the project stack.

A post_config can be passed that will be merged into the project configuration.

fun is called with the module name of the given Mix.Project. The return value of this function is the return value of fun.

Examples

Mix.Project.in_project(:my_app, "/path/to/my_app", fn module ->
  "Mix project is: #{inspect(module)}"
end)
#=> "Mix project is: MyApp.MixProject"

@spec manifest_path(keyword()) :: Path.t()

Returns the path where manifests are stored.

By default they are stored in the app path inside the build directory. Umbrella applications have the manifest path set to the root of the build directory. Directories may be changed in future releases.

The returned path will be expanded.

Examples

Mix.Project.manifest_path()
#=> "/path/to/project/_build/shared/lib/app/.mix"

@spec umbrella?(keyword()) :: boolean()

Returns true if config is the configuration for an umbrella project.

When called with no arguments, tells whether the current project is an umbrella project.