Use alias instead of import

Author: danschultzer

lib/phoenix_oauth2_provider/web/controllers/application_controller.ex

@@ -3,37 +3,46 @@ defmodule PhoenixOauth2Provider.ApplicationController do
   use PhoenixOauth2Provider.Web, :controller
 
   alias ExOauth2Provider.OauthApplications
-  import PhoenixOauth2Provider
 
   def index(conn, _params) do
-    applications = OauthApplications.get_applications_for(current_resource_owner(conn))
+    applications = conn
+                   |> PhoenixOauth2Provider.current_resource_owner()
+                   |> OauthApplications.get_applications_for()
+
     render(conn, "index.html", applications: applications)
   end
 
   def new(conn, _params) do
     changeset = OauthApplications.change_application(%OauthApplications.OauthApplication{})
+
     render(conn, "new.html", changeset: changeset)
   end
 
   def create(conn, %{"oauth_application" => application_params}) do
-    case OauthApplications.create_application(current_resource_owner(conn), application_params) do
+    conn
+    |> PhoenixOauth2Provider.current_resource_owner()
+    |> OauthApplications.create_application(application_params)
+    |> case do
       {:ok, application} ->
         conn
         |> put_flash(:info, "Application created successfully.")
-        |> redirect(to: router_helpers().oauth_application_path(conn, :show, application))
+        |> redirect(to: PhoenixOauth2Provider.router_helpers().oauth_application_path(conn, :show, application))
+
       {:error, %Ecto.Changeset{} = changeset} ->
         render(conn, "new.html", changeset: changeset)
     end
   end
 
   def show(conn, %{"uid" => uid}) do
     application = get_application_for!(conn, uid)
+
     render(conn, "show.html", application: application)
   end
 
   def edit(conn, %{"uid" => uid}) do
     application = get_application_for!(conn, uid)
     changeset = OauthApplications.change_application(application)
+
     render(conn, "edit.html", application: application, changeset: changeset)
   end
 
@@ -44,22 +53,24 @@ defmodule PhoenixOauth2Provider.ApplicationController do
       {:ok, application} ->
         conn
         |> put_flash(:info, "Application updated successfully.")
-        |> redirect(to: router_helpers().oauth_application_path(conn, :show, application))
+        |> redirect(to: PhoenixOauth2Provider.router_helpers().oauth_application_path(conn, :show, application))
       {:error, %Ecto.Changeset{} = changeset} ->
+
         render(conn, "edit.html", application: application, changeset: changeset)
     end
   end
 
   def delete(conn, %{"uid" => uid}) do
-    application = get_application_for!(conn, uid)
-    {:ok, _application} = OauthApplications.delete_application(application)
+    {:ok, _application} = conn
+                          |> get_application_for!(uid)
+                          |> OauthApplications.delete_application()
 
     conn
     |> put_flash(:info, "Application deleted successfully.")
-    |> redirect(to: router_helpers().oauth_application_path(conn, :index))
+    |> redirect(to: PhoenixOauth2Provider.router_helpers().oauth_application_path(conn, :index))
   end
 
   defp get_application_for!(conn, uid) do
-    OauthApplications.get_application_for!(current_resource_owner(conn), uid)
+    OauthApplications.get_application_for!(PhoenixOauth2Provider.current_resource_owner(conn), uid)
   end
 end

lib/phoenix_oauth2_provider/web/controllers/authorization_controller.ex

@@ -3,14 +3,16 @@ defmodule PhoenixOauth2Provider.AuthorizationController do
   use PhoenixOauth2Provider.Web, :controller
 
   alias ExOauth2Provider.Authorization
-  import PhoenixOauth2Provider
 
   def new(conn, params) do
-    case Authorization.preauthorize(current_resource_owner(conn), params) do
+    conn
+    |> PhoenixOauth2Provider.current_resource_owner()
+    |> Authorization.preauthorize(params)
+    |> case do
       {:ok, client, scopes} ->
         render(conn, "new.html", params: params, client: client, scopes: scopes)
       {:native_redirect, %{code: code}} ->
-        redirect(conn, to: router_helpers().oauth_authorization_path(conn, :show, code))
+        redirect(conn, to: PhoenixOauth2Provider.router_helpers().oauth_authorization_path(conn, :show, code))
       {:redirect, redirect_uri} ->
         redirect(conn, external: redirect_uri)
       {:error, error, status} ->
@@ -22,14 +24,14 @@ defmodule PhoenixOauth2Provider.AuthorizationController do
 
   def create(conn, params) do
     conn
-    |> current_resource_owner
+    |> PhoenixOauth2Provider.current_resource_owner()
     |> Authorization.authorize(params)
     |> redirect_or_render(conn)
   end
 
   def delete(conn, params) do
     conn
-    |> current_resource_owner
+    |> PhoenixOauth2Provider.current_resource_owner()
     |> Authorization.deny(params)
     |> redirect_or_render(conn)
   end

lib/phoenix_oauth2_provider/web/router.ex

@@ -32,10 +32,10 @@ defmodule PhoenixOauth2Provider.Router do
       end
   """
 
-  alias PhoenixOauth2Provider.AuthorizationController
-  alias PhoenixOauth2Provider.ApplicationController
-  alias PhoenixOauth2Provider.TokenController
-  alias PhoenixOauth2Provider.AuthorizedApplicationController
+  alias PhoenixOauth2Provider.{AuthorizationController,
+                               ApplicationController,
+                               TokenController,
+                               AuthorizedApplicationController}
 
   defmacro __using__(_opts \\ []) do
     quote do

test/phoenix_oauth2_provider_test.exs

@@ -1,15 +1,14 @@
 defmodule PhoenixOauth2ProviderTest do
   use PhoenixOauth2Provider.Test.ConnCase
-
-  import PhoenixOauth2Provider
+  alias PhoenixOauth2Provider
 
   test "current_resource_owner/1" do
-    assert current_resource_owner(%{assigns: %{current_test_user: "user"}}) == "user"
+    assert PhoenixOauth2Provider.current_resource_owner(%{assigns: %{current_test_user: "user"}}) == "user"
   end
 
   test "current_resource_owner/1 when not loaded" do
     assert_raise RuntimeError, "Resource owner was not found with :current_test_user assigns", fn ->
-      current_resource_owner(%{assigns: %{}})
+      PhoenixOauth2Provider.current_resource_owner(%{assigns: %{}})
     end
   end
 end