Reduce nested code in some functions (#336)

lib/hex/crypto/key_manager.ex

@@ -28,12 +28,7 @@ defmodule Hex.Crypto.KeyManager do
         case module.init(protected, opts) do
           {:ok, params} ->
             key_manager = %KeyManager{module: module, params: params}
-            case ContentEncryptor.init(protected, opts) do
-              {:ok, content_encryptor} ->
-                {:ok, key_manager, content_encryptor}
-              content_encryptor_error ->
-                content_encryptor_error
-            end
+            fetch_content_encryptor(key_manager, protected, opts)
           key_manager_error ->
             key_manager_error
         end
@@ -74,4 +69,13 @@ defmodule Hex.Crypto.KeyManager do
   defp key_manager_module("PBES2-HS384"), do: {:ok, Crypto.PBES2_HMAC_SHA2}
   defp key_manager_module("PBES2-HS512"), do: {:ok, Crypto.PBES2_HMAC_SHA2}
   defp key_manager_module(alg), do: {:error, "Unrecognized KeyManager algorithm: #{inspect alg}"}
+
+  defp fetch_content_encryptor(key_manager, protected, opts) do
+    case ContentEncryptor.init(protected, opts) do
+      {:ok, content_encryptor} ->
+        {:ok, key_manager, content_encryptor}
+      error ->
+        error
+    end
+  end
 end

lib/hex/crypto/pbes2_hmac_sha2.ex

@@ -30,12 +30,9 @@ defmodule Hex.Crypto.PBES2_HMAC_SHA2 do
       {:ok, password} ->
         case fetch_p2c(protected) do
           {:ok, _iteration} ->
-            case fetch_p2s(protected) do
-              {:ok, _salt} ->
-                {:ok, %{hash: hash, password: password}}
-              error ->
-                error
-            end
+            protected
+            |> fetch_p2s()
+            |> handle_p2s(hash, password)
           error ->
             error
         end
@@ -58,6 +55,9 @@ defmodule Hex.Crypto.PBES2_HMAC_SHA2 do
   end
   def decrypt(_, _, _, _), do: :error
 
+  defp handle_p2s({:ok, _salt}, hash, passwd), do: {:ok, %{hash: hash, password: passwd}}
+  defp handle_p2s(error, _, _), do: error
+
   defp fetch_password(opts) do
     case Keyword.fetch(opts, :password) do
       {:ok, password} when is_binary(password) -> {:ok, password}

lib/hex/remote_converger.ex

@@ -149,17 +149,22 @@ defmodule Hex.RemoteConverger do
       Hex.Shell.info "Dependency resolution completed:"
       resolved = Enum.sort(resolved)
       Enum.each(resolved, fn {name, version} ->
-        case Registry.retired(name, version) do
-          nil ->
-            Hex.Shell.info IO.ANSI.format [:green, "  #{name} #{version}"]
-          retired ->
-            Hex.Shell.warn "  #{name} #{version} RETIRED!"
-            Hex.Shell.warn "    (#{retirement_reason(retired[:reason])}) #{retired[:message]}"
-        end
+        name
+        |> Registry.retired(version)
+        |> print_status(name, version)
       end)
     end
   end
 
+  defp print_status(nil, name, version) do
+    Hex.Shell.info IO.ANSI.format [:green, "  #{name} #{version}"]
+  end
+
+  defp print_status(retired, name, version) do
+    Hex.Shell.warn "  #{name} #{version} RETIRED!"
+    Hex.Shell.warn "    (#{retirement_reason(retired[:reason])}) #{retired[:message]}"
+  end
+
   defp retirement_reason(:RETIRED_OTHER), do: "other"
   defp retirement_reason(:RETIRED_INVALID), do: "invalid"
   defp retirement_reason(:RETIRED_SECURITY), do: "security"
@@ -173,26 +178,33 @@ defmodule Hex.RemoteConverger do
 
       case Hex.Utils.lock(lock[String.to_atom(app)]) do
         [:hex, ^atom_name, ^version, checksum, _managers, deps] ->
-          registry_checksum = Registry.checksum(name, version)
-
-          if checksum && Base.decode16!(checksum, case: :lower) != registry_checksum,
-            do: Mix.raise "Registry checksum mismatch against lock (#{name} #{version})"
-
-          if deps do
-            deps =
-              Enum.map(deps, fn {app, req, opts} ->
-                {Atom.to_string(opts[:hex]), Atom.to_string(app), req, !!opts[:optional]}
-              end)
-
-            if Enum.sort(deps) != Enum.sort(Registry.deps(name, version)),
-              do: Mix.raise "Registry dependencies mismatch against lock (#{name} #{version})"
-          end
+          verify_registry(deps, name, version, checksum)
         _ ->
           :ok
       end
     end)
   end
 
+  defp verify_registry(deps, name, version, checksum) do
+    registry_checksum = Registry.checksum(name, version)
+    if checksum && Base.decode16!(checksum, case: :lower) != registry_checksum do
+      Mix.raise "Registry checksum mismatch against lock (#{name} #{version})"
+    end
+
+    if deps, do: verify_dependencies(deps, name, version)
+  end
+
+  defp verify_dependencies(deps, name, version) do
+    deps =
+      Enum.map(deps, fn {app, req, opts} ->
+        {Atom.to_string(opts[:hex]), Atom.to_string(app), req, !!opts[:optional]}
+      end)
+
+    if Enum.sort(deps) != Enum.sort(Registry.deps(name, version)) do
+      Mix.raise "Registry dependencies mismatch against lock (#{name} #{version})"
+    end
+  end
+
   defp check_lock(lock) do
     Enum.each(lock, fn {_app, info} ->
       case Hex.Utils.lock(info) do

lib/hex/resolver/backtracks.ex

@@ -99,7 +99,6 @@ defmodule Hex.Resolver.Backtracks do
             :error ->
               Map.put(map, name, [{[version], parents}|list])
           end
-
         :error ->
           Map.put(map, name, [{[version], parents}])
       end