Elixir proposal: optional dependencies for deploy

How about add optional dependencies?

defmodule MyApp.MixFile do
  use Mix.Project

  def project do
    [
      app: :my_app,
      version: "0.1.0",
      elixir: "~> 1.4",
      elixirc_paths: elixirc_paths(Mix.env),
      build_embedded: Mix.env == :prod,
      start_permanent: Mix.env == :prod,
      aliases: aliases(),
      deps: deps(),
      optional_deps: optional_deps(),
    ]
  end

  # ...
end

and example code:

defmodule MyApp.Things.Special do
  @behavior MyApp.Thing
  # don't compile this module if we don't have an optional library
  @module_depends_on: :optional_library

  def example(), do: OptionalLibrary.example()

  # or:

  # don't compile this method if we don't have an another optional library
  @depends_on: :another_optional_library
  def something(), do: AnotherOptionalLibrary.something()
end

mix deps.get should ask if we want an optional dependency in our setup.

Here I think like Gentoo user. In this source based distribution we can choose USE flags so we can compile package for example: with sound support and without bluetooth support. Of course it’s only simple example that probably should be more explained and discussed.

What do you think about my idea? Maybe instead of choosing packages we should choose something like USE flags, so we could provide easy pre-setup for deployment administrators?

We already support optional dependencies by specifying optional: true in your dependencies and then you can use something like if Code.ensure_loaded?(ModuleInADep) to check if a dependency is available or not.

6 Likes

@josevalim: Thanks for response. I see that I was not clear …

I found Mix.Tasks.Deps docs for it:

:optional - marks the dependency as optional. In such cases, the current project will always include the optional dependency but any other project that depends on the current project won’t be forced to use the optional dependency. However, if the other project includes the optional dependency on its own, the requirements and options specified here will also be applied.
It’s good for libraries, so primary project decides if dependency is required or not - that’s ok, but it’s not what I was looking for.

First of all my example is primary project - not 3rd party library - it’s ready (only example case) app to deploy.
Now we have based linux admin that got task to install our project and configure it. He needs to know what exactly packages provide features that he needs- I think it’s not clear for non-elixir administrators. We already know for what are floki, flow and other projects, but not everyone needs to know them.

Let me give another more complex example:

defmodule Example.Mixfile do
  use Mix.Project

  def application(), do: [extra_applications: [:logger]]

  def project do
    [
      app: :example,
      build_embedded: Mix.env == :prod,
      deploy_deps: deploy_deps(),
      deps: [],
      elixir: "~> 1.4.0",
      start_permanent: Mix.env == :prod,
      version: "0.1.0",
    ]
  end

  defp deploy_deps do
    [
      {
        # Simple groups descritpion like:
        :audio, [
          # optional package list for support audio
        ]
      }
    }
  end
end

and fetching dependencies:

mix deps.get
Running dependency resolution...

Getting required dependencies:
* Getting first_required_dependency (Hex package)
  Checking package (https://repo.hex.pm/tarballs/flow-0.11.0.tar)
  Fetched package

Would you like to add: "audio" support? [Y/n] Y
* Getting first_optional_audio_dependency (Hex package)
  Checking package (https://repo.hex.pm/tarballs/flow-0.11.0.tar)
  Fetched package
* Getting first_optional_audio_dependency (Hex package)
  Checking package (https://repo.hex.pm/tarballs/flow-0.11.0.tar)
  Fetched package

Would you like to add: "..." support? [Y/n] n
* Package first_optional_..._dependency (Hex package) is skipped.

Secondly, see comparison of if and module attribute:

if Code.ensure_loaded?(ModuleInADep) do
  defmodule ModuleName do
    # ...
  end
end

defmodule ModuleName do
  if Code.ensure_loaded?(ModuleInADep) do
    def method_a_name(), do: ModuleInADep.method_name()
  end
  
  if Code.ensure_loaded?(ModuleInBDep) do
    def method_b_name(), do: ModuleInBDep.method_name()
  end
end

# compare to:

defmodule ModuleName do
  # for example: where Experimental.Flow is declared?
  # I think that package name is much more cleaner here.
  @module_depends_on :package_name
  # ...
end

defmodule ModuleName do
  @depends_on: :optional_library_a
  def method_a_name(), do: ModuleInADep.method_name()
  
  @depends_on: :optional_library_b
  def method_b_name(), do: ModuleInBDep.method_name()
end

What do you think about it?