Making the plug dependency optional (#50)

* Making the plug dependency optional

* Fixing tests for migrations path

* Getting a better coverage

Author: kelvinst

lib/mix/tasks/triplex.gen.migration.ex

@@ -69,8 +69,7 @@ defmodule Mix.Tasks.Triplex.Gen.Migration do
     "#{y}#{pad(m)}#{pad(d)}#{pad(hh)}#{pad(mm)}#{pad(ss)}"
   end
 
-  defp pad(i) when i < 10, do: << ?0, ?0 + i >>
-  defp pad(i), do: to_string(i)
+  defp pad(i), do: i |> to_string() |> String.pad_leading(2, "0")
 
   embed_template :migration, """
   defmodule <%= inspect @mod %> do

lib/triplex/plugs/ensure_plug.ex

@@ -1,23 +1,24 @@
-defmodule Triplex.EnsurePlug do
-  @moduledoc """
-  This is a basic plug that ensure the tenant is loaded.
+if Code.ensure_loaded?(Plug) do
+  defmodule Triplex.EnsurePlug do
+    @moduledoc """
+    This is a basic plug that ensure the tenant is loaded.
 
-  To plug it on your router, you can use:
+    To plug it on your router, you can use:
 
-      plug Triplex.EnsurePlug,
-        callback: &TenantHelper.callback/2
-        failure_callback: &TenantHelper.failure_callback/2
+        plug Triplex.EnsurePlug,
+          callback: &TenantHelper.callback/2
+          failure_callback: &TenantHelper.failure_callback/2
 
-  See `Triplex.EnsurePlugConfig` to check all the allowed `config` flags.
-  """
+    See `Triplex.EnsurePlugConfig` to check all the allowed `config` flags.
+    """
 
-  import Triplex.Plug
-  alias Triplex.EnsurePlugConfig
+    import Triplex.Plug
+    alias Triplex.EnsurePlugConfig
 
-  @doc false
-  def init(opts), do: struct(EnsurePlugConfig, opts)
+    @doc false
+    def init(opts), do: struct(EnsurePlugConfig, opts)
 
-  @doc false
-  def call(conn, config), do: ensure_tenant(conn, config)
+    @doc false
+    def call(conn, config), do: ensure_tenant(conn, config)
+  end
 end
-

lib/triplex/plugs/param_plug.ex

@@ -1,32 +1,33 @@
-defmodule Triplex.ParamPlug do
-  @moduledoc """
-  This is a basic plug that loads the current tenant assign from a given
-  param.
-
-  To plug it on your router, you can use:
-
-      plug Triplex.ParamPlug,
-        param: :subdomain,
-        tenant_handler: &TenantHelper.tenant_handler/1
-
-  See `Triplex.ParamPlugConfig` to check all the allowed `config` flags.
-  """
-
-  import Triplex.Plug
-  alias Triplex.ParamPlugConfig
-
-  @doc false
-  def init(opts), do: struct(ParamPlugConfig, opts)
-
-  @doc false
-  def call(conn, config),
-    do: put_tenant(conn, get_param(conn, config), config)
-
-  defp get_param(conn, %ParamPlugConfig{param: key}),
-    do: get_param(conn, key)
-  defp get_param(conn, key) when is_atom(key),
-    do: get_param(conn, Atom.to_string(key))
-  defp get_param(conn, key),
-    do: conn.params[key]
+if Code.ensure_loaded?(Plug) do
+  defmodule Triplex.ParamPlug do
+    @moduledoc """
+    This is a basic plug that loads the current tenant assign from a given
+    param.
+
+    To plug it on your router, you can use:
+
+        plug Triplex.ParamPlug,
+          param: :subdomain,
+          tenant_handler: &TenantHelper.tenant_handler/1
+
+    See `Triplex.ParamPlugConfig` to check all the allowed `config` flags.
+    """
+
+    import Triplex.Plug
+    alias Triplex.ParamPlugConfig
+
+    @doc false
+    def init(opts), do: struct(ParamPlugConfig, opts)
+
+    @doc false
+    def call(conn, config),
+      do: put_tenant(conn, get_param(conn, config), config)
+
+    defp get_param(conn, %ParamPlugConfig{param: key}),
+      do: get_param(conn, key)
+    defp get_param(conn, key) when is_atom(key),
+      do: get_param(conn, Atom.to_string(key))
+    defp get_param(conn, key),
+      do: conn.params[key]
+  end
 end
-

lib/triplex/plugs/plug.ex

@@ -1,68 +1,69 @@
-defmodule Triplex.Plug do
-  @moduledoc """
-  This module have some basic functions for our triplex plugs.
+if Code.ensure_loaded?(Plug) do
+  defmodule Triplex.Plug do
+    @moduledoc """
+    This module have some basic functions for our triplex plugs.
 
-  The plugs we have for now are:
+    The plugs we have for now are:
 
-  - `Triplex.ParamPlug` - loads the tenant from a body or query param
-  - `Triplex.SessionPlug` - loads the tenant from a session param
-  - `Triplex.SubdomainPlug` - loads the tenant from the url subdomain
-  - `Triplex.EnsurePlug` - ensures the current tenant is loaded and halts if not
-  """
+    - `Triplex.ParamPlug` - loads the tenant from a body or query param
+    - `Triplex.SessionPlug` - loads the tenant from a session param
+    - `Triplex.SubdomainPlug` - loads the tenant from the url subdomain
+    - `Triplex.EnsurePlug` - ensures the current tenant is loaded and halts if not
+    """
 
-  import Plug.Conn
+    import Plug.Conn
 
-  @raw_tenant_assign :raw_current_tenant
+    @raw_tenant_assign :raw_current_tenant
 
-  @doc """
-  Puts the given `tenant` as an assign on the given `conn`, but only if the
-  tenant is not reserved.
+    @doc """
+    Puts the given `tenant` as an assign on the given `conn`, but only if the
+    tenant is not reserved.
 
-  The `config` map/struct must have:
+    The `config` map/struct must have:
 
-  - `tenant_handler`: function to handle the tenant param. Its return will
-  be used as the tenant.
-  - `assign`: the name of the assign where we must save the tenant.
-  """
-  def put_tenant(conn, tenant, config) do
-    if conn.assigns[config.assign] do
-      conn
-    else
-      conn = assign(conn, @raw_tenant_assign, tenant)
-      tenant = tenant_handler(tenant, config.tenant_handler)
-      if Triplex.reserved_tenant?(tenant) do
+    - `tenant_handler`: function to handle the tenant param. Its return will
+    be used as the tenant.
+    - `assign`: the name of the assign where we must save the tenant.
+    """
+    def put_tenant(conn, tenant, config) do
+      if conn.assigns[config.assign] do
         conn
       else
-        assign(conn, config.assign, tenant)
+        conn = assign(conn, @raw_tenant_assign, tenant)
+        tenant = tenant_handler(tenant, config.tenant_handler)
+        if Triplex.reserved_tenant?(tenant) do
+          conn
+        else
+          assign(conn, config.assign, tenant)
+        end
       end
     end
-  end
 
-  @doc """
-  Ensure the tenant is loaded, and if not, halts the `conn`.
+    @doc """
+    Ensure the tenant is loaded, and if not, halts the `conn`.
 
-  The `config` map/struct must have:
+    The `config` map/struct must have:
 
-  - `assign`: the name of the assign where we must save the tenant.
-  """
-  def ensure_tenant(conn, config) do
-    if loaded_tenant = conn.assigns[config.assign] do
-      callback(conn, loaded_tenant, config.callback)
-    else
-      conn
-      |> callback(conn.assigns[@raw_tenant_assign], config.failure_callback)
-      |> halt()
+    - `assign`: the name of the assign where we must save the tenant.
+    """
+    def ensure_tenant(conn, config) do
+      if loaded_tenant = conn.assigns[config.assign] do
+        callback(conn, loaded_tenant, config.callback)
+      else
+        conn
+        |> callback(conn.assigns[@raw_tenant_assign], config.failure_callback)
+        |> halt()
+      end
     end
-  end
 
-  defp tenant_handler(tenant, nil),
-    do: tenant
-  defp tenant_handler(tenant, handler) when is_function(handler),
-    do: handler.(tenant)
+    defp tenant_handler(tenant, nil),
+      do: tenant
+    defp tenant_handler(tenant, handler) when is_function(handler),
+      do: handler.(tenant)
 
-  defp callback(conn, _, nil),
-    do: conn
-  defp callback(conn, tenant, callback) when is_function(callback),
-    do: callback.(conn, tenant)
+    defp callback(conn, _, nil),
+      do: conn
+    defp callback(conn, tenant, callback) when is_function(callback),
+      do: callback.(conn, tenant)
+  end
 end
-

lib/triplex/plugs/session_plug.ex

@@ -1,26 +1,27 @@
-defmodule Triplex.SessionPlug do
-  @moduledoc """
-  This is a basic plug that loads the current tenant assign from a given
-  value set on session.
+if Code.ensure_loaded?(Plug) do
+  defmodule Triplex.SessionPlug do
+    @moduledoc """
+    This is a basic plug that loads the current tenant assign from a given
+    value set on session.
 
-  To plug it on your router, you can use:
+    To plug it on your router, you can use:
 
-      plug Triplex.SessionPlug,
-        session: :subdomain,
-        tenant_handler: &TenantHelper.tenant_handler/1
+        plug Triplex.SessionPlug,
+          session: :subdomain,
+          tenant_handler: &TenantHelper.tenant_handler/1
 
-  See `Triplex.SessionPlugConfig` to check all the allowed `config` flags.
-  """
+    See `Triplex.SessionPlugConfig` to check all the allowed `config` flags.
+    """
 
-  import Triplex.Plug
-  import Plug.Conn
-  alias Triplex.SessionPlugConfig
+    import Triplex.Plug
+    import Plug.Conn
+    alias Triplex.SessionPlugConfig
 
-  @doc false
-  def init(opts), do: struct(SessionPlugConfig, opts)
+    @doc false
+    def init(opts), do: struct(SessionPlugConfig, opts)
 
-  @doc false
-  def call(conn, config),
-    do: put_tenant(conn, get_session(conn, config.session), config)
+    @doc false
+    def call(conn, config),
+      do: put_tenant(conn, get_session(conn, config.session), config)
+  end
 end
-

lib/triplex/plugs/subdomain_plug.ex

@@ -1,40 +1,40 @@
-defmodule Triplex.SubdomainPlug do
-  @moduledoc """
-  This is a basic plug that loads the current tenant assign from a given
-  value set on subdomain.
+if Code.ensure_loaded?(Plug) do
+  defmodule Triplex.SubdomainPlug do
+    @moduledoc """
+    This is a basic plug that loads the current tenant assign from a given
+    value set on subdomain.
 
-  To plug it on your router, you can use:
+    To plug it on your router, you can use:
 
-      plug Triplex.SubdomainPlug,
-        endpoint: MyApp.Endpoint,
-        tenant_handler: &TenantHelper.tenant_handler/1
+        plug Triplex.SubdomainPlug,
+          endpoint: MyApp.Endpoint,
+          tenant_handler: &TenantHelper.tenant_handler/1
 
-  See `Triplex.SubdomainPlugConfig` to check all the allowed `config` flags.
-  """
+    See `Triplex.SubdomainPlugConfig` to check all the allowed `config` flags.
+    """
 
-  import Triplex.Plug
-  alias Plug.Conn
-  alias Triplex.SubdomainPlugConfig
+    import Triplex.Plug
+    alias Plug.Conn
+    alias Triplex.SubdomainPlugConfig
 
-  @doc false
-  def init(opts), do: struct(SubdomainPlugConfig, opts)
+    @doc false
+    def init(opts), do: struct(SubdomainPlugConfig, opts)
 
-  @doc false
-  def call(conn, config),
-    do: put_tenant(conn, get_subdomain(conn, config), config)
+    @doc false
+    def call(conn, config),
+      do: put_tenant(conn, get_subdomain(conn, config), config)
 
-  defp get_subdomain(_conn, %SubdomainPlugConfig{endpoint: nil}) do
-    nil
-  end
-  defp get_subdomain(%Conn{host: host},
-                     %SubdomainPlugConfig{endpoint: endpoint}) do
-    root_host = endpoint.config(:url)[:host]
-    if host in [root_host, "localhost", "127.0.0.1", "0.0.0.0"] do
+    defp get_subdomain(_conn, %SubdomainPlugConfig{endpoint: nil}) do
       nil
-    else
-      String.replace(host, ~r/.?#{root_host}/, "")
+    end
+    defp get_subdomain(%Conn{host: host},
+                      %SubdomainPlugConfig{endpoint: endpoint}) do
+      root_host = endpoint.config(:url)[:host]
+      if host in [root_host, "localhost", "127.0.0.1", "0.0.0.0"] do
+        nil
+      else
+        String.replace(host, ~r/.?#{root_host}/, "")
+      end
     end
   end
 end
-
-

mix.exs

@@ -49,9 +49,10 @@ defmodule Triplex.Mixfile do
   defp deps do
     [
       {:ecto, "~> 2.1"},
-      {:plug, "~> 1.3"},
       {:postgrex, ">= 0.11.0"},
 
+      {:plug, "~> 1.3", optional: true},
+
       {:ex_doc, ">= 0.0.0", only: :dev},
 
       {:inch_ex, only: :docs},
@@ -68,9 +69,9 @@ defmodule Triplex.Mixfile do
   # See the documentation for `Mix` for more info on aliases.
   defp aliases do
     ["db.migrate": ["ecto.migrate", "triplex.migrate"],
-     "test.reset": ["ecto.drop", "ecto.create", "db.migrate"],
-     "test.cover": &run_default_coverage/1,
-     "test.cover.html": &run_html_coverage/1]
+    "test.reset": ["ecto.drop", "ecto.create", "db.migrate"],
+    "test.cover": &run_default_coverage/1,
+    "test.cover.html": &run_html_coverage/1]
   end
 
   defp package do
@@ -86,11 +87,11 @@ defmodule Triplex.Mixfile do
 
   defp preferred_cli_env do
     ["coveralls": :test,
-     "coveralls.travis": :test,
-     "coveralls.detail": :test,
-     "coveralls.post": :test,
-     "coveralls.html": :test,
-     "test.reset": :test]
+    "coveralls.travis": :test,
+    "coveralls.detail": :test,
+    "coveralls.post": :test,
+    "coveralls.html": :test,
+    "test.reset": :test]
   end
 
   defp run_default_coverage(args), do: run_coverage("coveralls", args)